perm filename TEX.PSC[WEB,ALS] blob
sn#667824 filedate 1982-07-09 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00041 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00004 00002 {4}{8}{$C-,A+,D-}{[$C+,D+]} PROGRAM Tex
C00017 00003 PROCEDURE Initialize
C00028 00004 {55}PROCEDURE Println
C00033 00005 {74}PROCEDURE Gettoken
C00050 00006 {67} PROCEDURE Terminput
C00066 00007 {132}PROCEDURE Sortavail
C00077 00008 {174}PROCEDURE Shownodelist(p:halfword)
C00088 00009 {190}PROCEDURE Showbox(p:halfword)
C00095 00010 {208}PROCEDURE Pushnest
C00119 00011 {288}PROCEDURE Showcontext
C00140 00012 {337}PROCEDURE Gettoken
C00158 00013 {371}PROCEDURE Scanthe(level:smallnumber
C00185 00014 {430}PROCEDURE Beginname
C00196 00015 {473}PROCEDURE Readfontinfo(u:userfontcode
C00210 00016 {494}PROCEDURE Charwarning(f:internalfont
C00233 00017 {537}PROCEDURE Vlistout
C00258 00018 {597}PROCEDURE Showinfo
C00268 00019 {628}FUNCTION Cleanbox(p:halfword
C00295 00020 {664}PROCEDURE Pushalignmen
C00307 00021 {689}PROCEDURE Finrow
C00320 00022 {717}PROCEDURE Trybreak(pi:integer
C00337 00023 {789}FUNCTION Reconstitute(j,n:smallnumber):smallnumber
C00340 00024 {714}FUNCTION Finiteshrink(p:halfword):halfword
C00367 00025 {817}PROCEDURE Newhyphexcep
C00377 00026 {843}PROCEDURE Newpatterns
C00389 00027 {870}PROCEDURE Buildpage
C00404 00028 {899}{902}PROCEDURE Missingfont
C00416 00029 {956}PROCEDURE Package(c:smallnumber)
C00432 00030 {1005}PROCEDURE Doendv
C00456 00031 {1065}PROCEDURE Resumeafterd
C00465 00032 PROCEDURE Prefixedcomm
C00480 00033 {1134}PROCEDURE Doassignment
C00486 00034 {1159}PROCEDURE Storefmtfile
C00498 00035 {1205}{1206}PROCEDURE Newwhatsit(s:smallnumber
C00506 00036 PROCEDURE Maincontrol
C00520 00037 {1160}{439}FUNCTION Openfmtfile:boolean
C00522 00038 FUNCTION Loadfmtfile:boolean
C00534 00039 {1185}{1189}PROCEDURE Closefilesan
C00551 00040 {1196}{PROCEDURE DEBUGHELP
C00553 00041 {1188}BEGIN
C00557 ENDMK
C⊗;
{4}{8}{$C-,A+,D-}{[$C+,D+]} PROGRAM Tex;
LABEL
{5}1,2,9998,9999;
CONST
{10}memmax=30000;
bufsize=500;
errorline=64;
halferrorlin=32;
maxprintline=72;
stacksize=80;
maxinopen=6;
fontmax=75;
badfontcode=300;
fontmemsize=15000;
paramsize=30;
nestsize=40;
maxstrings=3000;
stringvacanc=8000;
poolsize=30000;
alignsize=4;
savesize=300;
triesize=7000;
dvibufsize=800;
filenamesize=40;
poolname='<TeX.sources>TEX.POOL ';
TYPE
{17}asciicode=0..127;
{24}eightbits=0..255;
alphafile=PACKED FILE OF char;
bytefile=PACKED FILE OF eightbits;
{37}poolpointer=0..poolsize;
strnumber=0..maxstrings;
{95}scaled=integer;
nonnegativei=0..2147483647;
smallnumber=0..63;
{103}glueratio=real;
{107}quarterword=0..255;
halfword=0..65535;
twochoices=1..2;
fourchoices=1..4;
twohalves=PACKED RECORD rh:halfword;
CASE twochoices OF 1:(lh:halfword);
2:(b0:quarterword;
b1:quarterword);
END;
fourquarters=PACKED RECORD b0:quarterword;
b1:quarterword;
b2:quarterword;
b3:quarterword;
END;
memoryword=PACKED RECORD CASE fourchoices OF 1:(int:integer);
2:(gr:glueratio);
3:(hh:twohalves);
4:(qqqq:fourquarters);
END;
wordfile=FILE OF memoryword;
{150}glueord=0..3;
{204}liststaterec=RECORD modefield:-185..185;
headfield,tailfield:halfword;
alreadyfield,auxfield,mlfield:integer;
END;
{250}groupcode=0..17;
{277}instaterecor=RECORD statefield,indexfield:quarterword;
startfield,locfield,limitfield,namefield:halfword;
END;
{463}userfontcode=0..badfontcode;
internalfont=0..fontmax;
{505}dviindex=0..dvibufsize;
{804}triepointer=0..triesize;
{809}hyphpointer=0..307;
VAR
{12}bad:integer;
{19}xord:ARRAY[char]OF asciicode;
xchr:ARRAY[asciicode]OF char;
{25}nameoffile:PACKED ARRAY[1..filenamesize]OF char;
namelength:0..filenamesize;
{29}buffer:ARRAY[0..bufsize]OF asciicode;
first:0..bufsize;
{31}termin:alphafile;
termout:alphafile;
{38}strpool:PACKED ARRAY[poolpointer]OF asciicode;
strstart:ARRAY[strnumber]OF poolpointer;
poolptr:poolpointer;
strptr:strnumber;
{49}poolfile:alphafile;
{53}errfile:alphafile;
selector:0..21;
dig:ARRAY[0..15]OF 0..9;
tally:integer;
offset:0..maxprintline;
trickbuf:ARRAY[0..errorline]OF asciicode;
trickcount:integer;
firstcount:integer;
{69}interaction:0..3;
{72}deletionsall:boolean;
spotless:boolean;
errorcount:0..100;
{75}helpline:ARRAY[0..5]OF strnumber;
helpptr:0..6;
{90}interrupt:integer;
oktointerrup:boolean;
{98}aritherror:boolean;
remainder:scaled;
{109}tempptr:halfword;
{110}mem:ARRAY[0..memmax]OF memoryword;
{111}varused,dynused:integer;
maxvarused:integer;
{112}avail:halfword;
memend:halfword;
{117}rover:halfword;
{124}{FREE:PACKED ARRAY[0..MEMMAX]OF BOOLEAN;
WASFREE:PACKED ARRAY[0..MEMMAX]OF BOOLEAN;
WASMEMEND:HALFWORD;
PANICKING:BOOLEAN;}{165}fontinshortd:quarterword;
{173}depththresho:integer;
breadthmax:integer;
{205}nest:ARRAY[0..nestsize]OF liststaterec;
nestptr:0..nestsize;
curlist:liststaterec;
{232}eqtb:ARRAY[1..4277]OF memoryword;
xeqlevel:ARRAY[3583..4277]OF quarterword;
{236}oldsetting:0..21;
saveoffset:0..maxprintline;
{237}hash:ARRAY[257..2359]OF twohalves;
hashused:halfword;
nonewcontrol:boolean;
csptr:halfword;
cscount:integer;
{252}savestack:ARRAY[0..savesize]OF memoryword;
saveptr:0..savesize;
curlevel:quarterword;
curgroup:groupcode;
curboundary:0..savesize;
{265}magset:integer;
{275}curcmd:eightbits;
curchr:halfword;
curtok:halfword;
{278}inputstack:ARRAY[0..stacksize]OF instaterecor;
inputptr:0..stacksize;
curinput:instaterecor;
{281}inopen:0..maxinopen;
inputfile:ARRAY[1..maxinopen]OF alphafile;
line:integer;
linestack:ARRAY[0..maxinopen]OF integer;
{282}scannerstatu:0..4;
warningindex:halfword;
{285}paramstack:ARRAY[0..paramsize]OF halfword;
paramptr:0..paramsize;
{286}alignstate:integer;
{287}baseptr:0..stacksize;
{309}parloc:halfword;
partoken:halfword;
{341}curmark:ARRAY[0..4]OF halfword;
{346}pstack:ARRAY[0..8]OF halfword;
{368}curval:integer;
curvallevel:0..4;
{390}radix:smallnumber;
{398}curorder:glueord;
{427}curname:strnumber;
curarea:strnumber;
curext:strnumber;
{428}areadelimite:poolpointer;
extdelimiter:poolpointer;
{435}texformatdef:PACKED ARRAY[1..22]OF char;
{443}jobname:strnumber;
{448}dvifile:bytefile;
outputfilena:strnumber;
{454}tfmfile:bytefile;
{464}fontinfo:ARRAY[0..fontmemsize]OF memoryword;
fmemptr:0..fontmemsize;
fontptr:internalfont;
fontcode:ARRAY[internalfont]OF userfontcode;
fontnumber:ARRAY[userfontcode]OF internalfont;
fontcheck:ARRAY[internalfont]OF fourquarters;
fontsize:ARRAY[internalfont]OF scaled;
fontscaled:ARRAY[internalfont]OF boolean;
fontparams:ARRAY[internalfont]OF halfword;
fontname:ARRAY[internalfont]OF strnumber;
fontarea:ARRAY[internalfont]OF strnumber;
fontbc:ARRAY[internalfont]OF eightbits;
fontec:ARRAY[internalfont]OF eightbits;
fontglue:ARRAY[internalfont]OF halfword;
fontused:ARRAY[internalfont]OF boolean;
{465}charbase:ARRAY[internalfont]OF integer;
widthbase:ARRAY[internalfont]OF integer;
heightbase:ARRAY[internalfont]OF integer;
depthbase:ARRAY[internalfont]OF integer;
italicbase:ARRAY[internalfont]OF integer;
ligkernbase:ARRAY[internalfont]OF integer;
kernbase:ARRAY[internalfont]OF integer;
extenbase:ARRAY[internalfont]OF integer;
parambase:ARRAY[internalfont]OF integer;
{468}nullcharacte:fourquarters;
{503}totalpages:integer;
maxv:scaled;
maxh:scaled;
maxpush:integer;
lastbop:integer;
c,f:quarterword;
hd:quarterword;
ruleht,ruledp,rulewd:scaled;
g:halfword;
lq,lr,lx:integer;
{506}dvibuf:ARRAY[dviindex]OF eightbits;
halfbuf:dviindex;
dvilimit:dviindex;
dviptr:dviindex;
dvioffset:integer;
dvigone:integer;
{513}downptr,rightptr:halfword;
{524}dvih,dviv:scaled;
curh,curv:scaled;
dvif:internalfont;
curs:integer;
{554}totalstretch,totalshrink:ARRAY[glueord]OF scaled;
{567}parbeginline:integer;
{589}emptyfield:twohalves;
{656}magicoffset:integer;
{662}curalign:halfword;
curspan:halfword;
alignptr:halfword;
{701}justbox:halfword;
{710}activewidth:ARRAY[1..6]OF scaled;
curactivewid:ARRAY[1..6]OF scaled;
background:ARRAY[1..6]OF scaled;
breakwidth:ARRAY[1..6]OF scaled;
{721}minimaldemer:ARRAY[0..3]OF scaled;
minimumdemer:scaled;
bestplace:ARRAY[0..3]OF halfword;
bestplline:ARRAY[0..3]OF halfword;
{777}hc:ARRAY[0..65]OF asciicode;
hn:smallnumber;
ha,hb:halfword;
hf:internalfont;
hu:ARRAY[1..63]OF asciicode;
{784}hyf:ARRAY[0..64]OF 0..9;
{805}trie:ARRAY[triepointer]OF twohalves;
hyfdistance:ARRAY[quarterword]OF smallnumber;
hyfnum:ARRAY[quarterword]OF smallnumber;
hyfnext:ARRAY[quarterword]OF quarterword;
{810}hyphword:ARRAY[hyphpointer]OF strnumber;
hyphlist:ARRAY[hyphpointer]OF halfword;
hyphcount:hyphpointer;
{826}trieophash:ARRAY[0..510]OF quarterword;
trieopptr:quarterword;
{828}triec:ARRAY[triepointer]OF asciicode;
trieo:ARRAY[triepointer]OF quarterword;
triel:ARRAY[triepointer]OF triepointer;
trier:ARRAY[triepointer]OF triepointer;
trieptr:triepointer;
{829}triehash:ARRAY[triepointer]OF triepointer;
{833}trietaken:ARRAY[triepointer]OF boolean;
triemax:triepointer;
triemin:triepointer;
{854}bestheight:scaled;
{863}pagetail:halfword;
emptypage:boolean;
pagesize:scaled;
pagedepthmax:scaled;
bestpagebrea:halfword;
leastpagebad:integer;
bestsize:scaled;
{865}pagesofar:ARRAY[1..6]OF scaled;
curpagedepth:scaled;
lastpageglue:halfword;
inspenalties:integer;
{867}outputactive:boolean;
{944}curbox:halfword;
{1140}errhelpseen:boolean;
{1156}formatident:strnumber;
{1162}fmtfile:wordfile;
{1186}readyalready:integer;
{1200}sendfile:ARRAY[0..15]OF alphafile;
sendopen:ARRAY[0..15]OF boolean;
PROCEDURE Initialize;
VAR
{18}i:0..127;
{163}k:integer;
{811}z:hyphpointer;
BEGIN{7}{20}
xchr[32]:=' '; xchr[33]:='!'; xchr[34]:='"'d xchr[35]:='#';
xchr[36]:='$'; xchr[37]:='%'; xchr[38]:='&'d xchr[39]:='''';
xchr[40]:='('; xchr[41]:=')'; xchr[42]:='*'d xchr[43]:='+';
xchr[44]:=','; xchr[45]:='-'; xchr[46]:='.'d xchr[47]:='/';
xchr[48]:='0'; xchr[49]:='1'; xchr[50]:='2'd xchr[51]:='3';
xchr[52]:='4'; xchr[53]:='5'; xchr[54]:='6'd xchr[55]:='7';
xchr[56]:='8'; xchr[57]:='9'; xchr[58]:=':'d xchr[59]:=';';
xchr[60]:='<'; xchr[61]:='='; xchr[62]:='>'d xchr[63]:='?';
xchr[64]:='@'; xchr[65]:='A'; xchr[66]:='B'd xchr[67]:='C';
xchr[68]:='D'; xchr[69]:='E'; xchr[70]:='F'd xchr[71]:='G';
xchr[72]:='H'; xchr[73]:='I'; xchr[74]:='J'd xchr[75]:='K';
xchr[76]:='L'; xchr[77]:='M'; xchr[78]:='N'd xchr[79]:='O';
xchr[80]:='P'; xchr[81]:='Q'; xchr[82]:='R'd xchr[83]:='S';
xchr[84]:='T'; xchr[85]:='U'; xchr[86]:='V'd xchr[87]:='W';
xchr[88]:='X'; xchr[89]:='Y'; xchr[90]:='Z'd xchr[91]:='[';
xchr[92]:='\'; xchr[93]:=']'; xchr[94]:='↑'d xchr[95]:='_';
xchr[96]:='`'; xchr[97]:='a'; xchr[98]:='b'd xchr[99]:='c';
xchr[100]:='d'; xchr[101]:='e'; xchr[102]:='f'd xchr[103]:='g';
xchr[104]:='h'; xchr[105]:='i'; xchr[106]:='j'd xchr[107]:='k';
xchr[108]:='l'; xchr[109]:='m'; xchr[110]:='n'd xchr[111]:='o';
xchr[112]:='p'; xchr[113]:='q'; xchr[114]:='r'd xchr[115]:='s';
xchr[116]:='t'; xchr[117]:='u'; xchr[118]:='v'd xchr[119]:='w';
xchr[120]:='x'; xchr[121]:='y'; xchr[122]:='z'd xchr[123]:='{';
xchr[124]:='|'; xchr[125]:='}'; xchr[126]:='~'d xchr[0]:=' ';
xchr[127]:=' ';
{22}
FOR i:=1 TO 31 DO xchr[i]:=' ';
{23}
FOR i:=0 TO 127 DO xord[Chr(i)]:=127;
FOR i:=1 TO 126 DO xord[xchr[i]]:=i;
{70}interaction:=3;
{73}deletionsall:=true;
spotless:=true;
errorcount:=0;
{91}interrupt:=0;
oktointerrup:=true;
{125}{WASMEMEND:=0;
PANICKING:=FALSE;}{207}nestptr:=0;
curlist.modefield:=1;
curlist.headfield:=12001;
curlist.tailfield:=12001;
curlist.auxfield:=-65536000;
curlist.mlfield:=0;
curlist.alreadyfield:=0;
{869}emptypage:=true;
pagetail:=12002;
lastpageglue:=65535;
inspenalties:=0;
{233}
FOR k:=3583 TO 4277 DO xeqlevel[k]:=1;
{238}nonewcontrol:=true;
hash[257].lh:=0;
hash[257].rh:=0;
FOR k:=258 TO 2359 DO hash[k]:=hash[257];
{253}saveptr:=0;
curlevel:=1;
curgroup:=0;
curboundary:=0;
{266}magset:=0;
{342}curmark[0]:=0;
curmark[1]:=0;
curmark[2]:=0;
curmark[3]:=0;
curmark[4]:=0;
{436}texformatdef:='<TeX.formats>BASIC.fmt';
{444}jobname:=0;
{466}
FOR k:=0 TO badfontcode DO fontnumber[k]:=0;
fontptr:=0;
fmemptr:=7;
fontcode[0]:=badfontcode;
fontbc[0]:=1;
fontec[0]:=0;
fontglue[0]:=0;
fontparams[0]:=7;
parambase[0]:=-1;
FOR k:=0 TO 6 DO fontinfo[k].int:=0;
FOR k:=0 TO fontmax DO fontused[k]:=false;
{469}nullcharacte.b0:=0;
nullcharacte.b1:=0;
nullcharacte.b2:=0;
nullcharacte.b3:=0;
{504}totalpages:=0;
maxv:=0;
maxh:=0;
maxpush:=0;
lastbop:=-1;
{507}halfbuf:=dvibufsize DIV 2;
dvilimit:=dvibufsize;
dviptr:=0;
dvioffset:=0;
dvigone:=0;
{514}downptr:=0;
rightptr:=0;
{568}parbeginline:=0;
{590}emptyfield.rh:=0;
emptyfield.lh:=0;
{663}alignptr:=0;
curalign:=0;
curspan:=0;
{812}
FOR z:=0 TO 307 DO hyphword[z]:=0;
hyphcount:=0;
{868}outputactive:=false;
{1141}errhelpseen:=false;
{1157}formatident:=0;
{1187}readyalready:=314159;
{1201}
FOR k:=0 TO 15 DO sendopen[k]:=false;
{164}
FOR k:=1 TO 19 DO mem[k].int:=0;
k:=0;
WHILE k<20 DO
BEGIN
mem[k].hh.rh:=1;
mem[k].hh.b0:=0;
mem[k].hh.b1:=0;
k:=k+4;
END;
mem[6].int:=65536;
mem[4].hh.b0:=1;
mem[10].int:=65536;
mem[8].hh.b0:=2;
mem[14].int:=65536;
mem[12].hh.b0:=1;
mem[15].int:=65536;
mem[12].hh.b1:=1;
mem[18].int:=-65536;
mem[16].hh.b0:=1;
rover:=20;
mem[rover].hh.rh:=65535;
mem[rover].hh.lh:=12000-rover;
mem[rover+1].hh.lh:=rover;
mem[rover+1].hh.rh:=rover;
mem[12000].hh.rh:=0;
mem[12000].hh.lh:=0;
FOR k:=12001 TO 12013 DO mem[k]:=mem[12000];
{681}mem[12011].hh.lh:=2304;
mem[12011].hh.rh:=0;
{707}mem[12007].hh.b0:=1;
mem[12008].hh.lh:=65535;
mem[12007].hh.b1:=0;
{864}mem[12000].hh.b1:=(255);
mem[12000].hh.b0:=1;
mem[12000].hh.rh:=12000;;
avail:=0;
memend:=12013;
varused:=0;
dynused:=memend-12000;
maxvarused:=0;
{213}eqtb[2360].hh.b0:=92;
eqtb[2360].hh.rh:=0;
eqtb[2360].hh.b1:=0;
FOR k:=1 TO 2359 DO eqtb[k]:=eqtb[2360];
{218}eqtb[2361].hh.rh:=0;
eqtb[2361].hh.b1:=1;
eqtb[2361].hh.b0:=98;
FOR k:=2362 TO 2633 DO eqtb[k]:=eqtb[2361];
mem[0].hh.rh:=mem[0].hh.rh+273;
{221}eqtb[2634].hh.rh:=0;
eqtb[2634].hh.b0:=99;
eqtb[2634].hh.b1:=1;
eqtb[2635]:=eqtb[2360];
eqtb[2636]:=eqtb[2360];
eqtb[2637].hh.rh:=0;
eqtb[2637].hh.b0:=100;
eqtb[2637].hh.b1:=1;
FOR k:=2638 TO 2892 DO eqtb[k]:=eqtb[2637];
eqtb[2893].hh.rh:=0;
eqtb[2893].hh.b0:=101;
eqtb[2893].hh.b1:=1;
FOR k:=2894 TO 2941 DO eqtb[k]:=eqtb[2893];
eqtb[2942].hh.rh:=0;
eqtb[2942].hh.b0:=101;
eqtb[2942].hh.b1:=1;
FOR k:=2943 TO 3582 DO eqtb[k]:=eqtb[eqtb[2942].hh.rh];
FOR k:=33 TO 126 DO
BEGIN
eqtb[2943+k].hh.rh:=12;
eqtb[3071+k].hh.rh:=k;
eqtb[3455+k].hh.rh:=1000;
END;
eqtb[2956].hh.rh:=5;
eqtb[2975].hh.rh:=10;
eqtb[3035].hh.rh:=0;
eqtb[3070].hh.rh:=15;
eqtb[2943].hh.rh:=9;
FOR k:=65 TO 90 DO
BEGIN
eqtb[2943+k].hh.rh:=11;
eqtb[2943+k+32].hh.rh:=11;
eqtb[3071+k].hh.rh:=k+28928;
eqtb[3071+k+32].hh.rh:=k+28960;
eqtb[3199+k].hh.rh:=k+32;
eqtb[3199+k+32].hh.rh:=k+32;
eqtb[3327+k].hh.rh:=k;
eqtb[3327+k+32].hh.rh:=k;
eqtb[3455+k].hh.rh:=999;
END;
{226}
FOR k:=3583 TO 3875 DO eqtb[k].int:=0;
eqtb[3600].int:=1000;
eqtb[3584].int:=10000;
FOR k:=0 TO 127 DO eqtb[3876+k].int:=-1;
{231}
FOR k:=4004 TO 4277 DO eqtb[k].int:=0;
{239}hashused:=2357;
cscount:=0;
{687}mem[12010].hh.rh:=256;
mem[12010].hh.lh:=0;
{835}trieopptr:=0;
trie[0].rh:=0;
trie[0].b1:=0;
trie[0].b0:=0;
FOR k:=1 TO 127 DO trie[k]:=trie[0];
triemax:=127;
{934}hash[2357].rh:=335;
eqtb[2357].hh.b1:=1;
eqtb[2357].hh.b0:=61;
eqtb[2357].hh.rh:=0;
hash[2358].rh:=608;
eqtb[2358].hh.b1:=1;
eqtb[2358].hh.b0:=47;
eqtb[2358].hh.rh:=30;
{1158}formatident:=966;
{1226}hash[2359].rh:=999;
eqtb[2359].hh.b1:=1;
eqtb[2359].hh.b0:=96;
eqtb[2359].hh.rh:=0;
END;
{55}PROCEDURE Println;
LABEL
10;
BEGIN
CASE selector OF
19:BEGIN
Writeln(termout);
Writeln(errfile);
END;
18:Writeln(errfile);
17:Writeln(termout);
16,20,21:GOTO 10;
OTHERS:Writeln(sendfile[selector])
END;
offset:=0;
10:
END;
{56}
PROCEDURE Printchar(c:asciicode);
LABEL
90;
BEGIN
CASE selector OF
19:BEGIN
Write(termout,xchr[c]);
Write(errfile,xchr[c]);
END;
18:Write(errfile,xchr[c]);
17:Write(termout,xchr[c]);
16:;
20:BEGIN
IF tally<trickcount THEN
trickbuf[tally MOD errorline]:=c;
GOTO 90;
END;
21:BEGIN
IF poolptr<poolsize THEN
BEGIN
strpool[poolptr]:=c;
poolptr:=poolptr+1;
END;
GOTO 90;
END;
OTHERS:BEGIN
Write(sendfile[selector],xchr[c]);
GOTO 90;
END
END;
offset:=offset+1;
IF offset=maxprintline THEN
Println;
90:
tally:=tally+1;
END;
{57}
PROCEDURE Print(s:strnumber);
VAR
j:poolpointer;
BEGIN
IF s>=strptr THEN
s:=0;
j:=strstart[s];
WHILE j<strstart[s+1]DO
BEGIN
Printchar(strpool[j]);
j:=j+1;
END;
END;
{59}
PROCEDURE Printnl(s:strnumber);
BEGIN
IF offset>0 THEN
Println;
Print(s);
END;
{60}
PROCEDURE Printesc(s:strnumber);
BEGIN
Printchar(92);
Print(s);
END;
{61}
PROCEDURE Printdigs(k:eightbits);
BEGIN
WHILE k>0 DO
BEGIN
k:=k-1;
Printchar(48+dig[k]);
END;
END;
{62}
PROCEDURE Printint(n:integer);
VAR
k:0..12;
m:nonnegativei;
BEGIN
k:=0;
IF n<0 THEN
BEGIN
Printchar(45);
IF n>-100000000 THEN
n:=-n
ELSE
BEGIN
m:=-1-n;
n:=m DIV 10;
m:=(m MOD 10)+1;
k:=1;
IF m<10 THEN
dig[0]:=m
ELSE
BEGIN
dig[0]:=0;
n:=n+1;
END;
END;
END;
REPEAT
dig[k]:=n MOD 10;
n:=n DIV 10;
k:=k+1;
UNTIL n=0;
Printdigs(k);
END;
{243}
PROCEDURE Printcs(p:halfword);
BEGIN
IF p<257 THEN
IF p>=129 THEN
Print(p-129)
ELSE
IF p<1 THEN
Printesc
(304)
ELSE
BEGIN
Printesc(p-1);
IF eqtb[2943+p].hh.rh=11 THEN
Printchar(32);
END
ELSE
IF p>=2360 THEN
Printesc(304)
ELSE
IF hash[p].rh=0 THEN
Printesc
(305)
ELSE
BEGIN
Printesc(hash[p].rh);
Printchar(32);
END;
END;
{433}
PROCEDURE Printfilenam(n,a,e:strnumber);
BEGIN
Printchar(96);
Print(a);
Print(n);
Print(e);
Printchar(39);
END;
{601}
PROCEDURE Printsize(s:smallnumber);
BEGIN
IF s=0 THEN
Printesc(614)
ELSE
IF s=16 THEN
Printesc(615)
ELSE
Printesc(616);
END;
{74}PROCEDURE Gettoken;
FORWARD;
PROCEDURE Terminput;
FORWARD;
PROCEDURE Showcontext;
FORWARD;
PROCEDURE Beginfilerea;
FORWARD;
PROCEDURE Closefilesan;
FORWARD;
PROCEDURE Clearforerro;
FORWARD;
{PROCEDURE DEBUGHELP;
FORWARD;}{76}
PROCEDURE Quit;
BEGIN
GOTO 9998;
END;
{77}
PROCEDURE Error;
LABEL
22,10;
VAR
c:asciicode;
s1,s2,s3:integer;
BEGIN
Printchar(46);
Showcontext;
IF interaction=3 THEN
{78}
WHILE true DO
BEGIN
22:
Clearforerro;
BEGIN
Print(63);
Terminput;
END;
IF curinput.limitfield=first THEN
GOTO 10;
c:=buffer[first];
IF c>=97 THEN
c:=c-32;
{79}
CASE c OF
49,50,51,52,53,54,55,56,57:IF deletionsall THEN
{83}
BEGIN
s1:=curtok;
s2:=curcmd;
s3:=curchr;
IF(curinput.limitfield>first+1)AND(buffer[first+1]>=48)
AND(buffer[first+1]<=57)THEN
c:=(c-48)*10+buffer[first+1];
WHILE c>48 DO
BEGIN
Gettoken;
c:=c-1;
END;
curtok:=s1;
curcmd:=s2;
curchr:=s3;
BEGIN
helpptr:=2;
helpline[1]:=142;
helpline[0]:=143;
END;
END;
{68:DEBUGHELP;
}72:{84}BEGIN
IF helpptr=0 THEN
BEGIN
helpptr:=2;
helpline[1]:=144;
helpline[0]:=145;
END;
REPEAT
helpptr:=helpptr-1;
Print(helpline[helpptr]);
Println;
UNTIL helpptr=0;
BEGIN
helpptr:=4;
helpline[3]:=146;
helpline[2]:=145;
helpline[1]:=147;
helpline[0]:=148;
END;
GOTO 22;
END;
73:{82}BEGIN
Beginfilerea;
curinput.namefield:=0;
IF curinput.limitfield>first+1 THEN
BEGIN
curinput.locfield:=first+1;
buffer[first]:=32;
END
ELSE
BEGIN
BEGIN
Print(141);
Terminput;
END;
curinput.locfield:=first;
END;
first:=curinput.limitfield;
curinput.limitfield:=curinput.limitfield-1;
GOTO 10;
END;
81,82,83:{81}BEGIN
errorcount:=0;
interaction:=0+c-81;
IF c=81 THEN
selector:=selector-1;
Println;
GOTO 10;
END;
88:BEGIN
BEGIN
Print(134);
Terminput;
END;
IF(curinput.limitfield>first)
AND((buffer[curinput.limitfield]=120)
OR(buffer[curinput.limitfield]=88))THEN Quit;
END;
OTHERS:
END;
{80}Print(135);
Printnl(136);
Printnl(137);
{IF BASEPTR>0 THEN PRINT(138);
}
IF deletionsall THEN
Printnl(139);
Printnl(140);;
END;
errorcount:=errorcount+1;
IF errorcount=100 THEN
BEGIN
Printnl(133);
Quit;
END;
{85}
IF interaction>0 THEN
selector:=selector-1;
WHILE helpptr>0 DO
BEGIN
helpptr:=helpptr-1;
Printnl(helpline[helpptr]);
END;
Println;
Println;
IF interaction>0 THEN
selector:=selector+1;
;
10:
END;
{87}
PROCEDURE Fatalerror(s:strnumber);
BEGIN
Printnl(150);
BEGIN
helpptr:=1;
helpline[0]:=s;
END;
BEGIN
IF interaction=3 THEN
interaction:=2;
Error;
Quit;
END;
END;
{88}
PROCEDURE Overflow(s:strnumber;
n:integer);
BEGIN
Printnl(151);
Print(s);
Printchar(61);
Printint(n);
Printchar(93);
BEGIN
helpptr:=2;
helpline[1]:=152;
helpline[0]:=153;
END;
BEGIN
IF interaction=3 THEN interaction:=2;
Error;
Quit;
END;
END;
{89}
PROCEDURE Confusion(s:strnumber);
BEGIN
IF spotless THEN
BEGIN
Printnl(154);
Print(s);
Printchar(41);
BEGIN
helpptr:=1;
helpline[0]:=155;
END;
END
ELSE
BEGIN
Printnl(156);
BEGIN
helpptr:=2;
helpline[1]:=157;
helpline[0]:=158;
END;
END;
BEGIN
IF interaction=3 THEN
interaction:=2;
Error;
Quit;
END;
END;
{26}
FUNCTION Aopenin(VAR f:alphafile):boolean;
BEGIN
Reset(f,nameoffile,'/O');
Aopenin:=NOT Eof(f);
END;
FUNCTION Aopenout(VAR f:alphafile):boolean;
BEGIN
Rewrite(f,nameoffile,'/O');
Aopenout:=Eof(f);
END;
FUNCTION Bopenin(VAR f:bytefile):boolean;
BEGIN
Reset(f,nameoffile,'/O');
Bopenin:=NOT Eof(f);
END;
FUNCTION Bopenout(VAR f:bytefile):boolean;
BEGIN
Rewrite(f,nameoffile,'/O');
Bopenout:=Eof(f);
END;
FUNCTION Wopenin(VAR f:wordfile):boolean;
BEGIN
Reset(f,nameoffile,'/O');
Wopenin:=NOT Eof(f);
END;
FUNCTION Wopenout(VAR f:wordfile):boolean;
BEGIN
Rewrite(f,nameoffile,'/O');
Wopenout:=Eof(f);
END;
{27}
PROCEDURE Aclose(VAR f:alphafile);
BEGIN
close(f);
END;
PROCEDURE Bclose(VAR f:bytefile);
BEGIN
close(f);
END;
PROCEDURE Wclose(VAR f:wordfile);
BEGIN
close(f);
END;
{30}
FUNCTION Inputln(VAR f:alphafile):boolean;
BEGIN
Get(f);
IF Eof(f)THEN
Inputln:=false
ELSE
BEGIN
curinput.limitfield:=first;
WHILE NOT Eoln(f)DO
BEGIN
IF curinput.limitfield+2>bufsize THEN
Overflow
(128,bufsize);
buffer[curinput.limitfield]:=xord[f↑];
Get(f);
curinput.limitfield:=curinput.limitfield+1;
END;
Inputln:=true;
END;
END;
{36}
FUNCTION Initterminal:boolean;
LABEL
10;
BEGIN
Reset(termin,'TTY:','/O');
WHILE true DO
BEGIN
Write(termout,'*');
Break(termout);
IF NOT Inputln(termin)THEN
BEGIN
Writeln(termout);
Write(termout,'! End of file on the terminal... why?');
Initterminal:=false;
GOTO 10;
END;
curinput.locfield:=first;
WHILE(curinput.locfield<curinput.limitfield)AND(buffer[curinput.locfield
]=32)DO curinput.locfield:=curinput.locfield+1;
IF curinput.locfield<curinput.limitfield THEN
BEGIN
Initterminal:=true;
GOTO 10;
END;
Writeln(termout,'Please type the name of your input file.');
END;
10:
END;
{42}
FUNCTION Makestring:strnumber;
BEGIN
IF strptr=maxstrings THEN
Overflow(130,maxstrings);
strptr:=strptr+1;
strstart[strptr]:=poolptr;
Makestring:=strptr-1;
END;
{44}
FUNCTION Streqbuf(s:strnumber;
k:integer):boolean;
LABEL
45;
VAR
j:poolpointer;
result:boolean;
BEGIN
j:=strstart[s];
result:=false;
WHILE j<strstart[s+1]DO
BEGIN
IF strpool[j]<>buffer[k]THEN
GOTO 45;
j:=j+1;
k:=k+1;
END;
result:=true;
45:
Streqbuf:=result;
END;
{45}
FUNCTION Streqstr(s,t:strnumber):boolean;
LABEL
45;
VAR
j,k:poolpointer;
result:boolean;
BEGIN
result:=false;
IF(strstart[s+1]-strstart[s])<>(strstart[t+1]-strstart[t])THEN
GOTO 45;
j:=strstart[s];
k:=strstart[t];
WHILE j<strstart[s+1]DO
BEGIN
IF strpool[j]<>strpool[k]THEN
GOTO 45;
j:=j+1;
k:=k+1;
END;
result:=true;
45:
Streqstr:=result;
END;
{46}
FUNCTION Initstrings:boolean;
LABEL
10;
VAR
k,l:0..127;
m,n:char;
g:strnumber;
a:integer;
c:boolean;
BEGIN
poolptr:=0;
strptr:=0;
{47}
FOR k:=0 TO 127 DO
BEGIN
IF(k<32)AND({48}true)THEN
BEGIN
BEGIN
strpool[poolptr]:=94;
poolptr:=poolptr+1;
END;
BEGIN
strpool[poolptr]:=94;
poolptr:=poolptr+1;
END;
BEGIN
strpool[poolptr]:=k+64;
poolptr:=poolptr+1;
END;
END
ELSE
IF k=127 THEN
BEGIN
BEGIN
strpool[poolptr]:=94;
poolptr:=poolptr+1;
END;
BEGIN
strpool[poolptr]:=94;
poolptr:=poolptr+1;
END;
BEGIN
strpool[poolptr]:=63;
poolptr:=poolptr+1;
END;
END
ELSE
BEGIN
strpool[poolptr]:=k;
poolptr:=poolptr+1;
END;
g:=Makestring;
END;
{50}nameoffile:=poolname;
IF Aopenin(poolfile)THEN
BEGIN
c:=false;
REPEAT{51}
BEGIN
IF Eof(poolfile)THEN
BEGIN
Writeln(termout,
'! TEX.POOL has no check sum.');
Initstrings:=false;
GOTO 10;
END;
Read(poolfile,m,n);
IF m='*'THEN
{52}
BEGIN
a:=0;
k:=1;
WHILE true DO
BEGIN
IF(xord[n]<48)OR(xord[n]>57)THEN
BEGIN
Writeln(
termout,'! TEX.POOL check sum doesn''t have nine digits.');
Initstrings:=false;
GOTO 10;
END;
a:=10*a+xord[n]-48;
IF k=9 THEN
GOTO 30;
k:=k+1;
Read(poolfile,n);
END;
30:
IF a<>157476531 THEN
BEGIN
Writeln(termout,
'! TEX.POOL doesn''t match; TANGLE me again.');
Initstrings:=false;
GOTO 10;
END;
c:=true;
END
ELSE
BEGIN
IF(xord[m]<48)OR(xord[m]>57)OR(xord[n]<48)OR(xord[n]>57)
THEN
BEGIN
Writeln(termout,
'! TEX.POOL line doesn''t begin with two digits.');
Initstrings:=false;
GOTO 10;
END;
l:=xord[m]*10+xord[n]-48*11;
IF poolptr+l+stringvacanc>poolsize THEN
BEGIN
Writeln(termout,
'! You have to increase POOLSIZE.');
Initstrings:=false;
GOTO 10;
END;
FOR k:=1 TO l DO
BEGIN
IF Eoln(poolfile)THEN
BEGIN
Writeln(termout,
'! TEX.POOL line too short.');
Initstrings:=false;
GOTO 10;
END;
Read(poolfile,m);
BEGIN
strpool[poolptr]:=xord[m];
poolptr:=poolptr+1;
END;
END;
Readln(poolfile);
g:=Makestring;
END;
END;
UNTIL c;
Initstrings:=true;
END
ELSE
BEGIN
Writeln(termout,'! I can''t read TEX.POOL.');
Initstrings:=false;
GOTO 10;
END;
10:
END;
{63}
PROCEDURE Printoctal(n:integer);
VAR
k:0..9;
BEGIN
k:=0;
Printchar(39);
REPEAT
dig[k]:=n MOD 8;
n:=n DIV 8;
k:=k+1;
UNTIL n=0;
Printdigs(k);
END;
{64}
PROCEDURE Printascii(c:asciicode);
BEGIN
IF(c>32)AND(c<=126)THEN
Printchar(c)
ELSE
BEGIN
Printoctal(c);
Printchar(32);
END;
END;
{65}
PROCEDURE Printromanin(n:nonnegativei);
LABEL
10;
VAR
j,k:poolpointer;
u,v:nonnegativei;
BEGIN
j:=strstart[131];
v:=1000;
WHILE true DO
BEGIN
WHILE n>=v DO
BEGIN
Printchar(strpool[j]);
n:=n-v;
END;
IF n=0 THEN
GOTO 10;
k:=j+2;
u:=v DIV(strpool[k-1]-48);
IF strpool[k-1]=50 THEN
BEGIN
k:=k+2;
u:=u DIV(strpool[k-1]-48);
END;
IF n+u>=v THEN
BEGIN
Printchar(strpool[k]);
n:=n+u;
END
ELSE
BEGIN
j:=j+2;
v:=v DIV(strpool[j-1]-48);
END;
END;
10:
END;
{66}
PROCEDURE Printcurrent;
VAR
j:poolpointer;
BEGIN
j:=strstart[strptr];
WHILE j<poolptr DO
BEGIN
Printchar(strpool[j]);
j:=j+1;
END;
END;
{67} PROCEDURE Terminput;
VAR
k:0..bufsize;
BEGIN
Break(termout);
IF NOT Inputln(termin)THEN
Fatalerror(132);
selector:=selector-1;
IF curinput.limitfield<>first THEN
FOR k:=first TO curinput.limitfield-1
DO Print(buffer[k]);
Println;
selector:=selector+1;
END;
{86}
PROCEDURE Interror(n:integer);
BEGIN
Print(149);
Printint(n);
Printchar(41);
Error;
END;
{92}
PROCEDURE Pauseforinst;
BEGIN
IF oktointerrup THEN
BEGIN
interaction:=3;
IF(selector=18)OR(selector=16)THEN
selector:=selector+1;
Print(159);
BEGIN
helpptr:=3;
helpline[2]:=160;
helpline[1]:=161;
helpline[0]:=162;
END;
deletionsall:=false;
Error;
deletionsall:=true;
interrupt:=0;
END;
END;
{94}
FUNCTION Half(x:integer):integer;
BEGIN
IF Odd(x)THEN
Half:=(x+1)DIV 2
ELSE
Half:=x DIV 2;
END;
{96}
FUNCTION Rounddecimal(k:smallnumber):scaled;
VAR
a:integer;
BEGIN
a:=0;
WHILE k>0 DO
BEGIN
k:=k-1;
a:=(a+dig[k]*131072)DIV 10;
END;
Rounddecimal:=(a+1)DIV 2;
END;
{97}
PROCEDURE Printscaled(s:scaled);
VAR
k:0..4;
BEGIN
IF s<0 THEN
BEGIN
Printchar(45);
s:=-s;
END;
Printint(s DIV 65536);
s:=((s MOD 65536)*100000+32768)DIV 65536;
FOR k:=0 TO 4 DO
BEGIN
dig[k]:=s MOD 10;
s:=s DIV 10;
END;
k:=4;
WHILE(dig[k]=0)AND(k>0)DO k:=k-1;
Printchar(46);
Printdigs(k+1);
END;
{99}
FUNCTION Nxplusy(n:integer;
x,y:scaled):scaled;
BEGIN
IF n<0 THEN
BEGIN
x:=-x;
n:=-n;
END;
IF(n=0)OR((x<=(1073741823-y)DIV n)AND(-x<=(1073741823+y)DIV n))THEN
Nxplusy:=n*x+y
ELSE
BEGIN
aritherror:=true;
Nxplusy:=0;
END;
END;
{100}
FUNCTION Xovern(x:scaled;
n:integer):scaled;
VAR
negate:boolean;
BEGIN
negate:=false;
IF n=0 THEN
BEGIN
aritherror:=true;
Xovern:=0;
remainder:=x;
END
ELSE
BEGIN
IF n<0 THEN
BEGIN
x:=-x;
n:=-n;
negate:=true;
END;
IF x>=0 THEN
BEGIN
Xovern:=x DIV n;
remainder:=x MOD n;
END
ELSE
BEGIN
Xovern:=-((-x)DIV n);
remainder:=-((-x)MOD n);
END;
END;
IF negate THEN
remainder:=-remainder;
END;
{101}
FUNCTION Xnoverd(x:scaled;
n,d:integer):scaled;
VAR
positive:boolean;
t,u,v:nonnegativei;
BEGIN
IF x>=0 THEN
positive:=true
ELSE
BEGIN
x:=-x;
positive:=false;
END;
t:=(x MOD 32768)*n;
u:=(x DIV 32768)*n+(t DIV 32768);
v:=(u MOD d)*32768+(t MOD 32768);
IF u DIV d>=32768 THEN
aritherror:=true
ELSE
u:=32768*(u DIV d)+(v DIV d
);
IF positive THEN
BEGIN
Xnoverd:=u;
remainder:=v MOD d;
END
ELSE
BEGIN
Xnoverd:=-u;
remainder:=-(v MOD d);
END;
END;
{102}
FUNCTION Badness(t,s:scaled):halfword;
VAR
r:integer;
BEGIN
IF t=0 THEN
Badness:=0
ELSE
IF s<=0 THEN
Badness:=10000
ELSE
BEGIN
IF t<=7230584 THEN
r:=(t*297)DIV s
ELSE
IF s>=1663497 THEN
r:=t DIV(s
DIV 297)
ELSE
r:=t;
IF r>1290 THEN
Badness:=10000
ELSE
Badness:=(r*r*r+131072)DIV 262144;
END;
END;
{108}{PROCEDURE PRINTMEMORYW(W:MEMORYWORD);
BEGIN PRINTINT(W.INT);
PRINTCHAR(32);
PRINTSCALED(W.INT);
PRINTCHAR(32);
PRINTSCALED(ROUND(65536*W.GR));
PRINTLN;
PRINTINT(W.HH.LH);
PRINTCHAR(61);
PRINTINT(W.HH.B0);
PRINTCHAR(58);
PRINTINT(W.HH.B1);
PRINTCHAR(59);
PRINTINT(W.HH.RH);
PRINTCHAR(32);
PRINTINT(W.QQQQ.B0);
PRINTCHAR(58);
PRINTINT(W.QQQQ.B1);
PRINTCHAR(58);
PRINTINT(W.QQQQ.B2);
PRINTCHAR(58);
PRINTINT(W.QQQQ.B3);
PRINTLN;
END;
}{113}{271}
PROCEDURE Showtokenlis(p,q:halfword;
l:integer);
LABEL
10;
VAR
m,c:integer;
matchchr:asciicode;
n:asciicode;
BEGIN
matchchr:=35;
n:=48;
tally:=0;
WHILE(p<>0)AND(tally<l)DO
BEGIN
IF p=q THEN
{297}
BEGIN
firstcount:=tally;
trickcount:=tally+1+errorline-halferrorlin;
IF trickcount<errorline THEN
trickcount:=errorline;
END;
{272}
IF(p<12000)OR(p>memend)THEN
BEGIN
Printesc(347);
GOTO 10;
END;
IF mem[p].hh.lh>=4096 THEN
Printcs(mem[p].hh.lh-4096)
ELSE
BEGIN
m:=mem[p
].hh.lh DIV 256;
c:=mem[p].hh.lh MOD 256;
IF(mem[p].hh.lh<0)OR(c>127)THEN
Printesc(348)
ELSE
{273}
CASE m OF
2,3,4,7,
8,10,11,12:Print(c);
1:BEGIN
IF(mem[p].hh.rh>=12000)AND(mem[p].hh.rh<=memend)THEN
IF mem[mem[
p].hh.rh].hh.lh DIV 256=14 THEN
Print(matchchr);
Print(c);
END;
9:Printesc(349);
6:BEGIN
Print(c);
Print(c);
END;
5:BEGIN
Print(matchchr);
IF c<=9 THEN
Printchar(c+48)
ELSE
BEGIN
Printchar(33);
GOTO 10;
END;
END;
13:BEGIN
matchchr:=c;
Print(c);
n:=n+1;
Printchar(n);
IF n>57 THEN
GOTO 10;
END;
14:Print(350);
OTHERS:Printesc(348)
END;
END;
p:=mem[p].hh.rh;
END;
IF p<>0 THEN
Printesc(346);
10:
END;
{283}
PROCEDURE Runaway;
VAR
p:halfword;
BEGIN
IF scannerstatu>1 THEN
BEGIN
Printnl(366);
CASE scannerstatu OF
2:BEGIN
Print(367);
p:=12003;
END;
3:BEGIN
Print(368);
p:=12003;
END;
4:BEGIN
Print(369);
p:=12004;
END;
END;
Println;
Showtokenlis(mem[p].hh.rh,0,errorline-10);
END;
END;
{114}
FUNCTION Getavail:halfword;
VAR
p:halfword;
BEGIN
p:=avail;
IF p<>0 THEN
avail:=mem[avail].hh.rh
ELSE
IF memend<memmax THEN
BEGIN
memend:=memend+1;
p:=memend;
END
ELSE
BEGIN
Runaway;
Overflow(163,memmax-0);
END;
mem[p].hh.rh:=0;
{DYNUSED:=DYNUSED+1;
}Getavail:=p;
END;
{116}
PROCEDURE Flushlist(p:halfword);
VAR
q:halfword;
BEGIN
WHILE p<>0 DO
BEGIN
q:=mem[p].hh.rh;
BEGIN
mem[p].hh.rh:=avail;
avail:=p;
{DYNUSED:=DYNUSED-1;}
END;
p:=q;
END;
END;
{118}
FUNCTION Getnode(s:integer):halfword;
LABEL
40;
VAR
p:halfword;
q:halfword;
r:halfword;
BEGIN
p:=rover;
REPEAT{120}
q:=p+mem[p].hh.lh;
WHILE(mem[q].hh.rh=65535)DO
BEGIN
IF q=rover THEN
rover:=mem[q+1].hh.rh;
mem[mem[q+1].hh.rh+1].hh.lh:=mem[q+1].hh.lh;
mem[mem[q+1].hh.lh+1].hh.rh:=mem[q+1].hh.rh;;
q:=q+mem[q].hh.lh;
END;
r:=q-s;
IF r>p+1 THEN
{121}
BEGIN
mem[p].hh.lh:=r-p;
rover:=p;
GOTO 40;
END;
IF(r=p)AND((mem[p+1].hh.rh<>rover)OR(mem[p+1].hh.lh<>rover))THEN
{122}
BEGIN
IF p=rover THEN
rover:=mem[p+1].hh.rh;
mem[mem[p+1].hh.rh+1].hh.lh:=mem[p+1].hh.lh;
mem[mem[p+1].hh.lh+1].hh.rh:=mem[p+1].hh.rh;;
rover:=mem[p+1].hh.rh;
GOTO 40;
END;
mem[p].hh.lh:=q-p;;
p:=mem[p+1].hh.rh;
UNTIL p=rover;
Overflow(164,12000);
40:
mem[r].hh.rh:=0;
{VARUSED:=VARUSED+S;
IF VARUSED>MAXVARUSED THEN MAXVARUSED:=VARUSED;}Getnode:=r;
END;
{123}
PROCEDURE Freenode(p:halfword;
s:halfword);
VAR
q:halfword;
BEGIN
mem[p].hh.lh:=s;
mem[p].hh.rh:=65535;
q:=mem[rover+1].hh.lh;
mem[p+1].hh.lh:=q;
mem[p+1].hh.rh:=rover;
mem[rover+1].hh.lh:=p;
mem[q+1].hh.rh:=p;
{VARUSED:=VARUSED-S;}
END;
{126}{PROCEDURE CHECKMEM(PRINTLOCS:BOOLEAN);
LABEL 31,32;
VAR P,Q:HALFWORD;
BEGIN FOR P:=0 TO MEMEND DO FREE[P]:=FALSE;
[127]P:=AVAIL;
Q:=0;
WHILE P<>0 DO BEGIN IF(P>MEMEND)OR(P<12000)OR FREE[P]THEN BEGIN PRINTNL(
165);
PRINTINT(Q);
GOTO 31;
END;
FREE[P]:=TRUE;
Q:=P;
P:=MEM[Q].HH.RH;
END;
31:;
[128]P:=ROVER;
Q:=0;
REPEAT IF(P>=12000)OR NOT((MEM[P].HH.RH=65535))OR(MEM[P].HH.LH<2)OR(P+
MEM[P].HH.LH>12000)OR(MEM[MEM[P+1].HH.RH+1].HH.LH<>P)THEN BEGIN PRINTNL(
166);
PRINTINT(Q);
GOTO 32;
END;
FOR Q:=P TO P+MEM[P].HH.LH-1 DO BEGIN IF FREE[Q]THEN BEGIN PRINTNL(167);
PRINTINT(Q);
GOTO 32;
END;
FREE[Q]:=TRUE;
END;
Q:=P;
P:=MEM[P+1].HH.RH;
UNTIL P=ROVER;
32:;[129]P:=0;
WHILE P<=12000 DO BEGIN IF(MEM[P].HH.RH=65535)THEN BEGIN PRINTNL(168);
PRINTINT(P);
END;
WHILE(P<=12000)AND NOT FREE[P]DO P:=P+1;
WHILE(P<=12000)AND FREE[P]DO P:=P+1;
END;;
IF PRINTLOCS THEN[130]BEGIN PRINTNL(169);
FOR P:=0 TO MEMEND DO IF NOT FREE[P]AND((P>WASMEMEND)OR WASFREE[P])THEN
BEGIN PRINTCHAR(32);
PRINTINT(P);
END;
END;
WASFREE:=FREE;
WASMEMEND:=MEMEND;
END;}{131}{PROCEDURE SEARCHMEM(P:HALFWORD);
VAR Q:HALFWORD;
BEGIN FOR Q:=0 TO MEMEND DO BEGIN IF MEM[Q].HH.RH=P THEN BEGIN PRINTNL(
170);
PRINTINT(Q);
PRINTCHAR(41);
END;
IF MEM[Q].HH.LH=P THEN BEGIN PRINTNL(171);
PRINTINT(Q);
PRINTCHAR(41);
END;
END;
[234]FOR Q:=1 TO 2892 DO BEGIN IF EQTB[Q].HH.RH=P THEN BEGIN PRINTNL(302
);
PRINTINT(Q);
PRINTCHAR(41);
END;
END;
END;}
{132}PROCEDURE Sortavail;
VAR
p,q,r:halfword;
oldrover:halfword;
BEGIN
p:=mem[rover+1].hh.rh;
mem[rover+1].hh.rh:=65535;
oldrover:=rover;
WHILE p<>oldrover DO{133}
IF p<rover THEN
BEGIN
q:=p;
p:=mem[q+1].hh.rh;
mem[q+1].hh.rh:=rover;
rover:=q;
END
ELSE
BEGIN
q:=rover;
WHILE mem[q+1].hh.rh<p DO q:=mem[q+1].hh.rh;
r:=mem[p+1].hh.rh;
mem[p+1].hh.rh:=mem[q+1].hh.rh;
mem[q+1].hh.rh:=p;
p:=r;
END;
p:=rover;
WHILE mem[p+1].hh.rh<>65535 DO
BEGIN
mem[mem[p+1].hh.rh+1].hh.lh:=p;
p:=mem[p+1].hh.rh;
END;
mem[p+1].hh.rh:=rover;
mem[rover+1].hh.lh:=p;
END;
{137}
FUNCTION Newnullbox:halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(7);
mem[p].hh.b0:=0;
mem[p].hh.b1:=0;
mem[p+1].int:=0;
mem[p+2].int:=0;
mem[p+3].int:=0;
mem[p+4].int:=0;
mem[p+5].hh.rh:=0;
mem[p+5].hh.b0:=0;
mem[p+5].hh.b1:=0;
mem[p+6].gr:=0.0;
Newnullbox:=p;
END;
{140}
FUNCTION Newrule:halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(4);
mem[p].hh.b0:=2;
mem[p].hh.b1:=0;
mem[p+1].int:=-1073741824;
mem[p+2].int:=-1073741824;
mem[p+3].int:=-1073741824;
Newrule:=p;
END;
{145}
FUNCTION Newligature(f,c:quarterword;
q:halfword):halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(2);
mem[p].hh.b0:=6;
mem[p].hh.b1:=0;
mem[p+1].hh.b0:=f;
mem[p+1].hh.b1:=c;
mem[p+1].hh.rh:=q;
Newligature:=p;
END;
{146}
FUNCTION Newdisc:halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(2);
mem[p].hh.b0:=7;
mem[p].hh.b1:=0;
mem[p+1].hh.lh:=0;
mem[p+1].hh.rh:=0;
Newdisc:=p;
END;
{151}
FUNCTION Newspec(p:halfword):halfword;
VAR
q:halfword;
BEGIN
q:=Getnode(4);
mem[q]:=mem[p];
mem[q].hh.rh:=0;
mem[q+1].int:=mem[p+1].int;
mem[q+2].int:=mem[p+2].int;
mem[q+3].int:=mem[p+3].int;
END;
{152}
FUNCTION Newparamglue(n:smallnumber):halfword;
VAR
p:halfword;
q:halfword;
BEGIN
p:=Getnode(2);
mem[p].hh.b0:=9;
mem[p].hh.b1:=n+1;
mem[p+1].hh.rh:=0;
q:={214}eqtb[2361+n].hh.rh;
mem[p+1].hh.lh:=q;
mem[q].hh.rh:=mem[q].hh.rh+1;
Newparamglue:=p;
END;
{153}
FUNCTION Newglue(q:halfword):halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(2);
mem[p].hh.b0:=9;
mem[p].hh.b1:=0;
mem[p+1].hh.rh:=0;
mem[p+1].hh.lh:=q;
mem[q].hh.rh:=mem[q].hh.rh+1;
Newglue:=p;
END;
{155}
FUNCTION Newkern(w:scaled):halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(2);
mem[p].hh.b0:=10;
mem[p].hh.b1:=0;
mem[p+1].int:=w;
Newkern:=p;
END;
{156}
FUNCTION Newmath(w:scaled;
s:smallnumber):halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(2);
mem[p].hh.b0:=11;
mem[p].hh.b1:=s;
mem[p+1].int:=w;
Newmath:=p;
END;
{158}
FUNCTION Newpenalty(m:integer):halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(2);
mem[p].hh.b0:=12;
mem[p].hh.b1:=0;
mem[p+1].int:=m;
END;
{166}
PROCEDURE Shortdisplay(p:halfword);
VAR
n:quarterword;
BEGIN
WHILE p<>0 DO
BEGIN
IF(p>12000)THEN
BEGIN
IF mem[p].hh.b0<>
fontinshortd THEN
BEGIN
Printesc(58);
Printint(fontcode[mem[p].hh.b0]);
Printchar(32);
fontinshortd:=mem[p].hh.b0;
END;
Printascii((mem[p].hh.b1-0));
END
ELSE
{167}
CASE mem[p].hh.b0 OF
0,1,2,3,8,4,5,13:Print(172);
9:Printchar(32);
11:Printchar(36);
6:Shortdisplay(mem[p+1].hh.rh);
7:BEGIN
Shortdisplay(mem[p+1].hh.lh);
Shortdisplay(mem[p+1].hh.rh);
n:=mem[p].hh.b1;
WHILE n>0 DO
BEGIN
p:=mem[p].hh.rh;
n:=n-1;
END;
END;
OTHERS:
END;
p:=mem[p].hh.rh;
END;
END;
{168}
PROCEDURE Printfontand(p:halfword);
BEGIN
Printesc(58);
Printint(fontcode[mem[p].hh.b0]);
Printchar(32);
Printascii((mem[p].hh.b1-0));
END;
PROCEDURE Printruledim(d:scaled);
BEGIN
IF(d=-1073741824)THEN
Printchar(42)
ELSE
Printscaled(d);
END;
{169}
PROCEDURE Printglue(d:scaled;
order:glueord;
s:strnumber);
BEGIN
Printscaled(d);
IF order>0 THEN
BEGIN
Print(173);
WHILE order>1 DO
BEGIN
Printchar(108);
order:=order-1;
END;
END
ELSE
IF s<>0 THEN
Print(s);
END;
{170}
PROCEDURE Printspec(p:halfword;
s:strnumber);
BEGIN
Printscaled(mem[p+1].int);
IF s<>0 THEN
Print(s);
IF mem[p+2].int<>0 THEN
BEGIN
Print(174);
Printglue(mem[p+2].int,mem[p].hh.b0,s);
END;
IF mem[p+3].int<>0 THEN
BEGIN
Print(175);
Printglue(mem[p+3].int,mem[p].hh.b1,s);
END;
END;
{171}{595}
PROCEDURE Printfamandc(p:halfword);
BEGIN
Printesc(314);
Printint(mem[p].hh.b0);
Printchar(32);
Printascii((mem[p].hh.b1-0));
END;
PROCEDURE Printdelimit(p:halfword);
VAR
a:integer;
BEGIN
a:=mem[p].qqqq.b0*256+(mem[p].qqqq.b1-0);
a:=a*4096+mem[p].qqqq.b2*256+(mem[p].qqqq.b3-0);
IF a<0 THEN
Printint(a)
ELSE
Printoctal(a);
END;
{596}
PROCEDURE Showinfo;
FORWARD;
PROCEDURE Printsubsidi(p:halfword;
c:asciicode);
BEGIN
IF(poolptr-strstart[strptr])<depththresho THEN
BEGIN
BEGIN
strpool
[poolptr]:=c;
poolptr:=poolptr+1;
END;
tempptr:=p;
CASE mem[p].hh.rh OF
1:BEGIN
Println;
Printcurrent;
Printfamandc(p);
END;
2:Showinfo;
3:IF mem[p].hh.lh=0 THEN
BEGIN
Println;
Printcurrent;
Print(592);
END
ELSE
Showinfo;
OTHERS:
END;
poolptr:=poolptr-1;
END;
END;
{598}
PROCEDURE Printstyle(c:smallnumber);
BEGIN
CASE c DIV 2 OF
0:Printesc(593);
1:Printesc(594);
2:Printesc(595);
3:Printesc(596);
OTHERS:Print(597)
END;
END;
{215}PROCEDURE Printskippar(n:smallnumber);
BEGIN
CASE n OF
0:Printesc(226);
1:Printesc(227);
2:Printesc(228);
3:Printesc(229);
4:Printesc(230);
5:Printesc(231);
6:Printesc(232);
7:Printesc(233);
8:Printesc(234);
9:Printesc(235);
10:Printesc(236);
11:Printesc(237);
12:Printesc(238);
13:Printesc(239);
14:Printesc(240);
15:Printesc(241);
16:Printesc(242);
OTHERS:Print(243)
END;
END;
{174}PROCEDURE Shownodelist(p:halfword);
LABEL
10;
VAR
n:integer;
BEGIN
IF(poolptr-strstart[strptr])>depththresho THEN
GOTO 10;
n:=0;
WHILE p>0 DO
BEGIN
Println;
Printcurrent;
IF p>memend THEN
BEGIN
Print(176);
GOTO 10;
END;
n:=n+1;
IF n>breadthmax THEN
BEGIN
Print(177);
GOTO 10;
END;
{175}
IF(p>12000)THEN
Printfontand(p)
ELSE
CASE mem[p].hh.b0 OF
0,1,13:{
176}
BEGIN
IF mem[p].hh.b0=0 THEN
Printesc(104)
ELSE
IF mem[p].hh.b0=1
THEN
Printesc(118)
ELSE
Printesc(179);
Print(180);
Printscaled(mem[p+3].int);
Printchar(43);
Printscaled(mem[p+2].int);
Print(181);
Printscaled(mem[p+1].int);
IF mem[p].hh.b0=13 THEN
{177}
BEGIN
IF mem[p].hh.b1<>0 THEN
BEGIN
Print(
149);
Printint((mem[p].hh.b1-0)+1);
Print(183);
END;
Print(184);
Printglue(mem[p+6].int,mem[p+5].hh.b1,0);
Print(185);
Printglue(mem[p+4].int,mem[p+5].hh.b0,0);
END
ELSE
BEGIN{178}
IF mem[p+6].gr<>0 THEN
BEGIN
Print(186);
IF mem[p+5].hh.b0=2 THEN
Print(187);
IF mem[p+6].gr>20000.0 THEN
BEGIN
Printchar(62);
Printglue(20000*65536,mem[p+5].hh.b1,0);
END
ELSE
Printglue(Round(mem[p+6].gr*65536),mem[p+5].hh.b1,0);
END;
IF mem[p+4].int<>0 THEN
BEGIN
Print(182);
Printscaled(mem[p+4].int);
END;
END;
BEGIN
BEGIN
strpool[poolptr]:=46;
poolptr:=poolptr+1;
END;
Shownodelist(mem[p+5].hh.rh);
poolptr:=poolptr-1;
END;
;
END;
2:{179}BEGIN
Printesc(188);
Printruledim(mem[p+3].int);
Printchar(43);
Printruledim(mem[p+2].int);
Print(181);
Printruledim(mem[p+1].int);
END;
3:{180}BEGIN
Printesc(189);
Printint((mem[p].hh.b1-0));
Print(190);
Printscaled(mem[p+1].int);
BEGIN
BEGIN
strpool[poolptr]:=46;
poolptr:=poolptr+1;
END;
Shownodelist(mem[p+2].int);
poolptr:=poolptr-1;
END;
;
END;
8:{1213}CASE mem[p].hh.b1 OF
0:BEGIN
Printesc(989);
Printint(mem[p+1].hh.lh);
Printchar(61);
Printfilenam(mem[p+1].hh.rh,mem[p+2].hh.lh,mem[p+2].hh.rh);
END;
1:BEGIN
Printesc(990);
Printint(mem[p+1].hh.lh);
Printchar(123);
Showtokenlis(mem[mem[p+1].hh.rh].hh.rh,0,errorline-15);
Printchar(125);
END;
2:BEGIN
Printesc(991);
Printint(mem[p+1].hh.lh);
END;
3:BEGIN
Printesc(992);
Printchar(123);
Showtokenlis(mem[mem[p+1].hh.rh].hh.rh,0,errorline-15);
Printchar(125);
END;
OTHERS:Print(995)
END;
;
9:{181}IF mem[p].hh.b1>=100 THEN
{182}
BEGIN
Printchar(92);
IF mem[p].hh.b1=101 THEN
Printchar(99)
ELSE
IF mem[p].hh.b1=102 THEN
Printchar(120);
Print(195);
Printspec(mem[p+1].hh.lh,0);
BEGIN
BEGIN
strpool[poolptr]:=46;
poolptr:=poolptr+1;
END;
Shownodelist(mem[p+1].hh.rh);
poolptr:=poolptr-1;
END;
;
END
ELSE
BEGIN
Printesc(191);
IF mem[p].hh.b1<>0 THEN
BEGIN
Printchar(40);
IF mem[p].hh.b1<99 THEN
Printskippar(mem[p].hh.b1-1)
ELSE
IF mem[p].hh.b1
=99 THEN
Printesc(192)
ELSE
BEGIN
Printesc(193);
Printchar(32);
Printspec(mem[p+1].hh.lh,194);
END;
END;
IF mem[p].hh.b1<99 THEN
BEGIN
Printchar(32);
Printspec(mem[p+1].hh.lh,0);
END;
END;
10:{183}IF mem[p].hh.b1=0 THEN
BEGIN
Printesc(196);
Printscaled(mem[p+1].int);
END
ELSE
BEGIN
Printesc(197);
Printscaled(mem[p+1].int);
Print(194);
END;
11:{184}BEGIN
Printesc(198);
IF mem[p].hh.b1=0 THEN
Print(199)
ELSE
Print(200);
IF mem[p+1].int<>0 THEN
BEGIN
Print(201);
Printscaled(mem[p+1].int);
END;
END;
6:{185}BEGIN
Printfontand(p+1);
Print(202);
fontinshortd:=mem[p+1].hh.b0;
Shortdisplay(mem[p+1].hh.rh);
Printchar(41);
END;
12:{186}BEGIN
Printesc(203);
Printint(mem[p+1].int);
END;
7:{187}BEGIN
Printesc(204);
IF mem[p].hh.b1>0 THEN
BEGIN
Print(205);
Printint(mem[p].hh.b1);
END;
IF mem[p+1].hh.lh=0 THEN
Print(206)
ELSE
BEGIN
BEGIN
strpool[poolptr]:=46
;
poolptr:=poolptr+1;
END;
Shownodelist(mem[p+1].hh.lh);
poolptr:=poolptr-1;
END;
;
BEGIN
strpool[poolptr]:=124;
poolptr:=poolptr+1;
END;
Shownodelist(mem[p+1].hh.rh);
poolptr:=poolptr-1;
END;
4:{188}BEGIN
Printesc(207);
Showtokenlis(mem[mem[p+1].int].hh.rh,0,errorline-10);
Printchar(125);
END;
5:{189}BEGIN
Printesc(208);
BEGIN
BEGIN
strpool[poolptr]:=46;
poolptr:=poolptr+1;
END;
Shownodelist(mem[p+1].int);
poolptr:=poolptr-1;
END;
;
END;
{594}14:Printstyle(mem[p].hh.b1);
15,16,17,18,19,20,21,23,26,25,28,27,29,30:{599}BEGIN
CASE mem[p].hh.b0
OF
15:Printesc(598);
16:Printesc(599);
17:Printesc(600);
18:Printesc(601);
19:Printesc(602);
20:Printesc(603);
21:Printesc(604);
26:Printesc(605);
25:Printesc(606);
28:Printesc(332);
23:BEGIN
Printesc(336);
Printdelimit(p+4);
END;
27:BEGIN
Printesc(327);
Printfamandc(p+4);
END;
29:BEGIN
Printesc(607);
Printdelimit(p+1);
END;
30:BEGIN
Printesc(608);
Printdelimit(p+1);
END;
END;
IF mem[p].hh.b1<>0 THEN
Printesc(330);
IF mem[p].hh.b0<29 THEN
Printsubsidi(p+1,46);
Printsubsidi(p+2,40);
Printsubsidi(p+3,91);
END;
24:{600}BEGIN
Printesc(609);
Print(610);
IF mem[p+1].int=1073741824 THEN
Print(611)
ELSE
Printscaled(mem[p+1].int);
IF(mem[p+4].qqqq.b0<>0)OR(mem[p+4].qqqq.b1<>0)
OR(mem[p+4].qqqq.b2<>0)OR(mem[p+4].qqqq.b3<>0)THEN
BEGIN
Print(612);
Printdelimit(p+4);
END;
IF(mem[p+5].qqqq.b0<>0)OR(mem[p+5].qqqq.b1<>0)
OR(mem[p+5].qqqq.b2<>0)OR(mem[p+5].qqqq.b3<>0)THEN
BEGIN
Print(613);
Printdelimit(p+5);
END;
Printsubsidi(p+2,92);
Printsubsidi(p+3,47);
END;
OTHERS:Print(178)
END;
p:=mem[p].hh.rh;
END;
10:
END;
{190}PROCEDURE Showbox(p:halfword);
BEGIN{222}
depththresho:=eqtb[3607].int;
breadthmax:=eqtb[3608].int;
IF breadthmax<=0 THEN
breadthmax:=5;
BEGIN
IF poolptr+depththresho>poolsize THEN
Overflow(129,poolsize);
END;
Shownodelist(p);
Println;
END;
{192}
PROCEDURE Deletetokenr(p:halfword);
BEGIN
IF mem[p].hh.lh=0 THEN
Flushlist(p)
ELSE
mem[p].hh.lh:=mem[p].hh.lh
-1;
END;
{193}
PROCEDURE Deletegluere(p:halfword);
BEGIN
IF mem[p].hh.rh=0 THEN
Freenode(p,4)
ELSE
mem[p].hh.rh:=mem[p].hh.
rh-1;
END;
{194}
PROCEDURE Flushnodelis(p:halfword);
LABEL
30;
VAR
q:halfword;
BEGIN
WHILE p<>0 DO
BEGIN
q:=mem[p].hh.rh;
IF(p>12000)THEN
BEGIN
mem[p].hh.rh:=avail;
avail:=p;
{DYNUSED:=DYNUSED-1;
}
END
ELSE
BEGIN
CASE mem[p].hh.b0 OF
0,1,13:BEGIN
Flushnodelis(mem[p+5].
hh.rh);
Freenode(p,7);
GOTO 30;
END;
2:BEGIN
Freenode(p,4);
GOTO 30;
END;
3:BEGIN
Flushnodelis(mem[p+2].int);
Freenode(p,3);
GOTO 30;
END;
8:{1215}BEGIN
CASE mem[p].hh.b1 OF
0:Freenode(p,3);
1,3:BEGIN
Deletetokenr(mem[p+1].hh.rh);
Freenode(p,2);
GOTO 30;
END;
2:Freenode(p,2);
OTHERS:Confusion(997)
END;
GOTO 30;
END;
;
9:BEGIN
Deletegluere(mem[p+1].hh.lh);
Flushnodelis(mem[p+1].hh.rh);
END;
10,11,12:;
6:Flushnodelis(mem[p+1].hh.rh);
4:Deletetokenr(mem[p+1].int);
7:BEGIN
Flushnodelis(mem[p+1].hh.lh);
Flushnodelis(mem[p+1].hh.rh);
END;
5:Flushnodelis(mem[p+1].int);
OTHERS:Confusion(209)
END;
Freenode(p,2);
30:
END;
p:=q;
END;
END;
{196}
FUNCTION Copynodelist(p:halfword):halfword;
VAR
h:halfword;
q:halfword;
r:halfword;
words:0..5;
BEGIN
h:=Getavail;
q:=h;
WHILE p<>0 DO
BEGIN{197}
words:=1;
IF(p>12000)THEN
r:=Getavail
ELSE
{198}
CASE mem[p].hh.b0 OF
0,1,13:BEGIN
r
:=Getnode(7);
mem[r+6]:=mem[p+6];
mem[r+5]:=mem[p+5];
mem[r+5].hh.rh:=Copynodelist(mem[p+5].hh.rh);
words:=5;
END;
2:BEGIN
r:=Getnode(4);
words:=4;
END;
3:BEGIN
r:=Getnode(3);
mem[r+2].int:=Copynodelist(mem[p+2].int);
words:=2;
END;
8:{1214}CASE mem[p].hh.b1 OF
0:BEGIN
r:=Getnode(3);
words:=3;
END;
1,3:BEGIN
r:=Getnode(2);
mem[mem[p+1].hh.rh].hh.lh:=mem[mem[p+1].hh.rh].hh.lh+1;
words:=2;
END;
2:BEGIN
r:=Getnode(2);
words:=2;
END;
OTHERS:Confusion(996)
END;
;
9:BEGIN
r:=Getnode(2);
mem[mem[p+1].hh.lh].hh.rh:=mem[mem[p+1].hh.lh].hh.rh+1;
mem[r+1].hh.lh:=mem[p+1].hh.lh;
mem[r+1].hh.rh:=Copynodelist(mem[p+1].hh.rh);
END;
10,11,12:BEGIN
r:=Getnode(2);
words:=2;
END;
6:BEGIN
r:=Getnode(2);
mem[r+1]:=mem[p+1];
mem[r+1].hh.rh:=Copynodelist(mem[p+1].hh.rh);
END;
7:BEGIN
r:=Getnode(2);
mem[r+1].hh.lh:=Copynodelist(mem[p+1].hh.lh);
mem[r+1].hh.rh:=Copynodelist(mem[p+1].hh.rh);
END;
4:BEGIN
r:=Getnode(2);
mem[mem[p+1].int].hh.lh:=mem[mem[p+1].int].hh.lh+1;
words:=2;
END;
5:BEGIN
r:=Getnode(2);
mem[r+1].int:=Copynodelist(mem[p+1].int);
END;
OTHERS:Confusion(210)
END;
WHILE words>0 DO
BEGIN
words:=words-1;
mem[r+words]:=mem[p+words];
END;
mem[q].hh.rh:=r;
q:=r;
p:=mem[p].hh.rh;
END;
mem[q].hh.rh:=0;
q:=mem[h].hh.rh;
BEGIN
mem[h].hh.rh:=avail;
avail:=h;
{DYNUSED:=DYNUSED-1;}
END;
Copynodelist:=q;
END;
{203}
PROCEDURE Printmode(m:integer);
BEGIN
IF m>0 THEN
CASE m DIV(92)OF
0:Print(211);
1:Print(212);
2:Print(213);
END
ELSE
CASE(-m)DIV(92)OF
0:Print(214);
1:Print(215);
2:Print(198);
END;
END;
{208}PROCEDURE Pushnest;
BEGIN
IF nestptr=nestsize THEN
Overflow(216,nestsize);
nest[nestptr]:=curlist;
nestptr:=nestptr+1;
curlist.headfield:=Getavail;
curlist.tailfield:=curlist.headfield;
curlist.alreadyfield:=0;
curlist.mlfield:=line;
END;
{209}
PROCEDURE Popnest;
BEGIN
BEGIN
mem[curlist.headfield].hh.rh:=avail;
avail:=curlist.headfield;
{DYNUSED:=DYNUSED-1;}
END;
nestptr:=nestptr-1;
curlist:=nest[nestptr];
END;
{210}
PROCEDURE Showactiviti;
VAR
p:0..nestsize;
m:-185..185;
a:integer;
BEGIN
nest[nestptr]:=curlist;
FOR p:=nestptr DOWNTO 0 DO
BEGIN
m:=nest[p].modefield;
a:=nest[p].auxfield;
Printnl(217);
Printmode(m);
Print(218);
Printint(Abs(nest[p].mlfield));
IF nest[p].mlfield<0 THEN
Print(219);
CASE Abs(m)DIV(92)OF
0:BEGIN
Print(220);
IF a<=-65536000 THEN
Print(221)
ELSE
Printscaled(a);
IF nest[p].alreadyfield<>0 THEN
BEGIN
Print(222);
Printint(nest[p].alreadyfield);
END;
END;
1:BEGIN
Print(223);
Printint(a);
END;
2:IF a<>0 THEN
BEGIN
Print(224);
Showbox(a);
END;
END;
Showbox(mem[nest[p].headfield].hh.rh);
END;
Printnl(225);
Showbox(mem[12002].hh.rh);
END;
{223}
PROCEDURE Printparam(n:smallnumber);
BEGIN
CASE n OF
0:Printesc(246);
1:Printesc(247);
2:Printesc(248);
3:Printesc(249);
4:Printesc(250);
5:Printesc(251);
6:Printesc(252);
7:Printesc(253);
8:Printesc(254);
9:Printesc(255);
10:Printesc(256);
11:Printesc(257);
12:Printesc(258);
13:Printesc(259);
14:Printesc(260);
15:Printesc(261);
16:Printesc(262);
17:Printesc(263);
18:Printesc(264);
19:Printesc(265);
20:Printesc(266);
21:Printesc(267);
22:Printesc(268);
23:Printesc(269);
24:Printesc(270);
25:Printesc(271);
26:Printesc(272);
27:Printesc(273);
28:Printesc(274);
29:Printesc(275);
30:Printesc(276);
31:Printesc(277);
32:Printesc(278);
33:Printesc(279);
34:Printesc(280);
35:Printesc(281);
36:Printesc(282);
OTHERS:Print(283)
END;
END;
{227}
PROCEDURE Fixdateandti;
BEGIN
eqtb[3603].int:=12*60;
eqtb[3604].int:=4;
eqtb[3605].int:=7;
eqtb[3606].int:=1776;
END;
{228}
PROCEDURE Printlengthp(n:smallnumber);
BEGIN
CASE n OF
0:Printesc(284);
1:Printesc(285);
2:Printesc(286);
3:Printesc(287);
4:Printesc(288);
5:Printesc(289);
6:Printesc(290);
7:Printesc(291);
8:Printesc(292);
9:Printesc(293);
10:Printesc(294);
11:Printesc(295);
12:Printesc(296);
13:Printesc(297);
14:Printesc(298);
15:Printesc(299);
16:Printesc(300);
OTHERS:Print(301)
END;
END;
{235}
PROCEDURE Begindiagnos;
BEGIN
oldsetting:=selector;
saveoffset:=offset;
IF(eqtb[3612].int=0)AND(selector=19)THEN
selector:=selector-1;
END;
PROCEDURE Enddiagnosti;
BEGIN
IF offset>0 THEN
Println;
selector:=oldsetting;
IF(eqtb[3612].int=0)AND(oldsetting=19)THEN
offset:=saveoffset;
END;
{240}
FUNCTION Idlookup(j,l:integer):halfword;
LABEL
40;
VAR
h:integer;
p:halfword;
k:halfword;
BEGIN{242}
h:=buffer[j];
FOR k:=j+1 TO j+l-1 DO
BEGIN
h:=h+h+buffer[k];
WHILE h>=1777 DO h:=h-1777;
END;
;
p:=h+257;
WHILE true DO
BEGIN
IF(hash[p].rh>0)AND((strstart[hash[p].rh+1]-strstart
[hash[p].rh])=l)THEN
IF Streqbuf(hash[p].rh,j)THEN
GOTO 40;
IF hash[p].lh=0 THEN
BEGIN
IF nonewcontrol THEN
p:=2360
ELSE
{241}
BEGIN
IF hash[p].rh>0 THEN
BEGIN
REPEAT
IF(hashused=257)THEN
Overflow(303,2100
);
hashused:=hashused-1;
UNTIL hash[hashused].rh=0;
hash[p].lh:=hashused;
p:=hashused;
END;
BEGIN
IF poolptr+l>poolsize THEN
Overflow(129,poolsize);
END;
FOR k:=j TO j+l-1 DO
BEGIN
strpool[poolptr]:=buffer[k];
poolptr:=poolptr+1;
END;
hash[p].rh:=Makestring;
{CSCOUNT:=CSCOUNT+1;}
END;
GOTO 40;
END;
p:=hash[p].lh;
END;
40:
Idlookup:=p;
END;
{244}
PROCEDURE Sprintcs(p:halfword);
BEGIN
IF p<257 THEN
IF p<129 THEN
Printesc(p-1)
ELSE
Print(p-129)
ELSE
Printesc(hash[p].rh);
END;
{245}
PROCEDURE Primitive(s:strnumber;
c:quarterword;
o:halfword);
VAR
k:poolpointer;
j:smallnumber;
l:smallnumber;
BEGIN
IF s<128 THEN
curval:=s+1
ELSE
BEGIN
k:=strstart[s];
l:=strstart[s+1]-k;
FOR j:=0 TO l-1 DO buffer[j]:=strpool[k+j];
curval:=Idlookup(0,l);
BEGIN
strptr:=strptr-1;
poolptr:=strstart[strptr];
END;
hash[curval].rh:=s;
END;
eqtb[curval].hh.b1:=1;
eqtb[curval].hh.b0:=c;
eqtb[curval].hh.rh:=o;
END;
{255}
PROCEDURE Newsavelevel(c:groupcode);
BEGIN
IF saveptr>savesize-6 THEN
Overflow(337,savesize);
;
savestack[saveptr].hh.b0:=2;
savestack[saveptr].hh.b1:=curgroup;
savestack[saveptr].hh.rh:=curboundary;
IF curlevel=255 THEN
Overflow(338,255);
curboundary:=saveptr;
curlevel:=curlevel+1;
saveptr:=saveptr+1;
curgroup:=c;
END;
{256}
PROCEDURE Eqdestroy(w:memoryword);
VAR
q:halfword;
BEGIN
CASE w.hh.b0 OF
94,95,96,97:Deletetokenr(w.hh.rh);
98:Deletegluere(w.hh.rh);
99:BEGIN
q:=w.hh.rh;
Freenode(q,mem[q].hh.rh+mem[q].hh.rh+1);
END;
100:Flushnodelis(w.hh.rh);
OTHERS:
END;
END;
{257}
PROCEDURE Eqsave(p:halfword;
l:quarterword);
BEGIN
IF saveptr>savesize-6 THEN
Overflow(337,savesize);
;
IF l=0 THEN
savestack[saveptr].hh.b0:=1
ELSE
BEGIN
savestack[saveptr]:=
eqtb[p];
saveptr:=saveptr+1;
savestack[saveptr].hh.b0:=0;
END;
savestack[saveptr].hh.b1:=l;
savestack[saveptr].hh.rh:=p;
saveptr:=saveptr+1;
END;
{258}
PROCEDURE Eqdefine(p:halfword;
t:quarterword;
e:halfword);
BEGIN
IF eqtb[p].hh.b1=curlevel THEN
Eqdestroy(eqtb[p])
ELSE
IF curlevel>
1 THEN
Eqsave(p,eqtb[p].hh.b1);
eqtb[p].hh.b1:=curlevel;
eqtb[p].hh.b0:=t;
eqtb[p].hh.rh:=e;
END;
{259}
PROCEDURE Eqworddefine(p:halfword;
w:integer);
BEGIN
IF xeqlevel[p]<>curlevel THEN
BEGIN
Eqsave(p,xeqlevel[p]);
xeqlevel[p]:=curlevel;
END;
eqtb[p].int:=w;
END;
{260}
PROCEDURE Geqdefine(p:halfword;
t:quarterword;
e:halfword);
BEGIN
Eqdestroy(eqtb[p]);
eqtb[p].hh.b1:=1;
eqtb[p].hh.b0:=t;
eqtb[p].hh.rh:=e;
END;
PROCEDURE Geqworddefin(p:halfword;
w:integer);
BEGIN
eqtb[p].int:=w;
xeqlevel[p]:=1;
END;
{261}
PROCEDURE Unsave;
LABEL
30;
VAR
p:halfword;
l:quarterword;
BEGIN
IF curlevel>1 THEN
BEGIN
curlevel:=curlevel-1;
{262}
WHILE true DO
BEGIN
saveptr:=saveptr-1;
IF savestack[saveptr].hh.b0=2 THEN
GOTO 30;
p:=savestack[saveptr].hh.rh;
IF savestack[saveptr].hh.b0=0 THEN
BEGIN
l:=savestack[saveptr].hh.b1;
saveptr:=saveptr-1;
END
ELSE
savestack[saveptr]:=eqtb[2360];
{263}
IF p<3583 THEN
IF eqtb[p].hh.b1=1 THEN
Eqdestroy(savestack[saveptr]
)
ELSE
BEGIN
Eqdestroy(eqtb[p]);
eqtb[p]:=savestack[saveptr];
END
ELSE
IF xeqlevel[p]<>1 THEN
BEGIN
eqtb[p]:=savestack[saveptr];
xeqlevel[p]:=l;
END;
END;
30:
curgroup:=savestack[saveptr].hh.b1;
curboundary:=savestack[saveptr].hh.rh;
END
ELSE
Confusion(339);
END;
{264}
PROCEDURE Leavetranspa;
VAR
j,k:0..savesize;
BEGIN
j:=savestack[curboundary].hh.rh;
curgroup:=savestack[curboundary].hh.b1;
FOR k:=curboundary TO saveptr-2 DO savestack[k]:=savestack[k+1];
saveptr:=saveptr-1;
curboundary:=j;
END;
{267}
PROCEDURE Preparemag;
BEGIN
IF(magset>0)AND(eqtb[3600].int<>magset)THEN
BEGIN
Printnl(340);
Printint(eqtb[3600].int);
Print(341);
BEGIN
helpptr:=2;
helpline[1]:=342;
helpline[0]:=343;
END;
Interror(magset);
Geqworddefin(3600,magset);
END;
IF(eqtb[3600].int<=0)OR(eqtb[3600].int>32768)THEN
BEGIN
Printnl(344);
BEGIN
helpptr:=1;
helpline[0]:=345;
END;
Interror(eqtb[3600].int);
Geqworddefin(3600,1000);
END;
magset:=eqtb[3600].int;
END;
{274}
PROCEDURE Tokenshow(p:halfword);
BEGIN
IF p=0 THEN
Print(351)
ELSE
Showtokenlis(mem[p].hh.rh,0,1000);
END;
{276}
PROCEDURE Printcmdchr(cmd:quarterword;
chrcode:halfword);
BEGIN
CASE cmd OF
1:BEGIN
Print(352);
Printascii(chrcode);
END;
2:BEGIN
Print(353);
Printascii(chrcode);
END;
3:BEGIN
Print(354);
Printascii(chrcode);
END;
4:IF chrcode=128 THEN
Printesc(355)
ELSE
BEGIN
Print(356);
Printascii(chrcode);
END;
5:Printesc(357);
6:BEGIN
Print(358);
Printascii(chrcode);
END;
7:BEGIN
Print(359);
Printascii(chrcode);
END;
8:BEGIN
Print(360);
Printascii(chrcode);
END;
9:Print(361);
10:Print(362);
11:BEGIN
Print(363);
Printascii(chrcode);
END;
12:BEGIN
Print(364);
Printascii(chrcode);
END;
{217}73:Printskippar(chrcode);
{220}70:IF chrcode=2635 THEN
Printesc(244)
ELSE
Printesc(245);
{225}71:Printparam(chrcode);
{230}72:Printlengthp(chrcode);
{247}0:Printesc(306);
81:Printesc(307);
16:Printesc(308);
17:Printesc(309);
18:Printesc(310);
19:Printesc(311);
40:Printesc(312);
83:Printesc(313);
78:Printesc(58);
79:Printesc(314);
66:Printesc(315);
88:Printesc(316);
24:Printesc(317);
25:Printesc(318);
68:Printesc(319);
32:Printesc(320);
33:Printesc(321);
34:Printesc(322);
35:Printesc(323);
36:Printesc(324);
37:Printesc(189);
38:Printesc(208);
89:Printesc(326);
42:Printesc(47);
43:Printesc(327);
15:Printesc(329);
49:Printesc(330);
52:Printesc(331);
53:Printesc(332);
62:Printesc(333);
60:Printesc(334);
61:Printesc(335);
63:Printesc(32);
64:Printesc(336);
{311}13:Printesc(383);
{344}93:CASE chrcode OF
1:Printesc(413);
2:Printesc(414);
3:Printesc(415);
4:Printesc(416);
OTHERS:Printesc(412)
END;
{370}67:IF chrcode=0 THEN
Printesc(443)
ELSE
IF chrcode=1 THEN
Printesc(
444)
ELSE
Printesc(445);
75:Printesc(446);
65:IF chrcode=0 THEN
Printesc(447)
ELSE
Printesc(448);
{375}69:IF chrcode=1 THEN
Printesc(452)
ELSE
Printesc(451);
{916}14:IF chrcode=1 THEN
Printesc(698)
ELSE
Printesc(697);
{928}26:CASE chrcode OF
4:Printesc(708);
0:Printesc(709);
1:Printesc(710);
2:Printesc(711);
OTHERS:Printesc(712)
END;
27:CASE chrcode OF
4:Printesc(713);
0:Printesc(714);
1:Printesc(715);
2:Printesc(716);
OTHERS:Printesc(717)
END;
28:Printesc(193);
29:Printesc(196);
30:Printesc(197);
{941}22:IF chrcode=1 THEN
Printesc(738)
ELSE
Printesc(739);
23:IF chrcode=1 THEN
Printesc(740)
ELSE
Printesc(741);
21:CASE chrcode OF
0:Printesc(742);
1:Printesc(743);
2:Printesc(744);
3:Printesc(745);
4:Printesc(746);
5:Printesc(747);
OTHERS:Printesc(748);
END;
31:IF chrcode=100 THEN
Printesc(749)
ELSE
IF chrcode=101 THEN
Printesc(
750)
ELSE
Printesc(751);
{959}41:IF chrcode=0 THEN
Printesc(766)
ELSE
Printesc(765);
{985}45:IF chrcode=1 THEN
Printesc(45)
ELSE
Printesc(204);
{1014}46:IF chrcode=1 THEN
Printesc(805)
ELSE
Printesc(804);
{1027}48:CASE chrcode OF
15:Printesc(598);
16:Printesc(599);
17:Printesc(600);
18:Printesc(601);
19:Printesc(602);
20:Printesc(603);
21:Printesc(604);
25:Printesc(606);
OTHERS:Printesc(605)
END;
{1039}51:Printstyle(chrcode);
{1046}50:CASE chrcode OF
1:Printesc(823);
2:Printesc(824);
3:Printesc(609);
4:Printesc(825);
5:Printesc(825);
OTHERS:Printesc(822)
END;
{1055}47:IF chrcode=29 THEN
Printesc(607)
ELSE
Printesc(608);
{1074}55:CASE chrcode OF
1:Printesc(840);
2:Printesc(841);
3:Printesc(842);
4:Printesc(843);
5:Printesc(844);
6:Printesc(845);
7:Printesc(846);
8:Printesc(847);
9:Printesc(848);
OTHERS:Printesc(839)
END;
{1091}80:IF chrcode=1 THEN
Printesc(867)
ELSE
IF chrcode=2 THEN
Printesc(
868)
ELSE
Printesc(869);
82:IF chrcode=0 THEN
Printesc(870)
ELSE
IF chrcode=1 THEN
Printesc(871)
ELSE
IF chrcode=2 THEN
Printesc(872)
ELSE
Printesc(873);
{1106}76:IF chrcode=2943 THEN
Printesc(889)
ELSE
IF chrcode=3071 THEN
Printesc(890)
ELSE
IF chrcode=3199 THEN
Printesc(891)
ELSE
IF chrcode=3327
THEN
Printesc(892)
ELSE
IF chrcode=3455 THEN
Printesc(893)
ELSE
Printesc(
894);
77:Printsize(chrcode-2894);
{1111}84,85,86,87:BEGIN
CASE cmd OF
84:Printesc(914);
85:Printesc(915);
86:Printesc(916);
OTHERS:Printesc(917)
END;
IF chrcode=0 THEN
Print(443)
ELSE
IF chrcode=1 THEN
Print(444)
ELSE
Print(
445);
END;
{1121}90:IF chrcode=1 THEN
Printesc(926)
ELSE
Printesc(925);
{1131}91:CASE chrcode OF
0:Printesc(935);
1:Printesc(936);
2:Printesc(937);
OTHERS:Printesc(938)
END;
{1137}58:IF chrcode=0 THEN
Printesc(939)
ELSE
Printesc(940);
{1145}54:IF chrcode=3199 THEN
Printesc(946)
ELSE
Printesc(947);
{1150}20:CASE chrcode OF
1:Printesc(949);
2:Printesc(950);
3:Printesc(951);
OTHERS:Printesc(948)
END;
{1153}92:Print(959);
94:Print(960);
95:Printesc(961);
96:Printesc(962);
97:Printesc(963);
{1203}59:CASE chrcode OF
0:Printesc(989);
1:Printesc(990);
2:Printesc(991);
3:Printesc(992);
OTHERS:Print(993)
END;
OTHERS:Confusion(365)
END;
END;
{288}PROCEDURE Showcontext;
LABEL
30;
VAR
oldsetting:0..21;
{292}i:0..bufsize;
j:0..bufsize;
l:0..halferrorlin;
m:integer;
n:0..errorline;
p:integer;
q:integer;
BEGIN
baseptr:=inputptr;
inputstack[baseptr]:=curinput;
WHILE true DO
BEGIN
curinput:=inputstack[baseptr];
{289}
IF(curinput.statefield<>0)OR(curinput.indexfield<>3)
OR(curinput.locfield<>0)THEN
BEGIN
tally:=0;
oldsetting:=selector;
IF curinput.statefield<>0 THEN
BEGIN{290}
IF(curinput.namefield=0)THEN
IF
baseptr=0 THEN
Print(370)
ELSE
Print(371)
ELSE
BEGIN
Print(372);
Printint(line);
END;
Printchar(32);;
{295}
BEGIN
l:=tally;
tally:=0;
selector:=20;
trickcount:=1000000;
END;
IF buffer[curinput.limitfield]=13 THEN
j:=curinput.limitfield-1
ELSE
j:=
curinput.limitfield;
FOR i:=curinput.startfield TO j DO
BEGIN
IF i=curinput.locfield THEN
BEGIN
firstcount:=tally;
trickcount:=tally+1+errorline-halferrorlin;
IF trickcount<errorline THEN
trickcount:=errorline;
END;
Print(buffer[i]);
END;
IF curinput.locfield>j THEN
BEGIN
firstcount:=tally;
trickcount:=tally+1+errorline-halferrorlin;
IF trickcount<errorline THEN
trickcount:=errorline;
END;
;
END
ELSE
BEGIN{291}
CASE curinput.indexfield OF
0:Print(373);
1,2:Print(374);
3:Print(375);
4:Printcs(curinput.namefield);
5:Print(376);
6:Print(377);
7:Printesc(378);
8:Print(379);
OTHERS:Printchar(63)
END;
{296}
BEGIN
l:=tally;
tally:=0;
selector:=20;
trickcount:=1000000;
END;
IF curinput.indexfield<4 THEN
Showtokenlis(curinput.startfield,curinput.
locfield,100000)
ELSE
Showtokenlis(mem[curinput.startfield].hh.rh,
curinput.locfield,100000);
;
END;
selector:=oldsetting;
{294}
IF tally<trickcount THEN
m:=tally-firstcount
ELSE
m:=trickcount-
firstcount;
IF l+firstcount<=halferrorlin THEN
BEGIN
p:=0;
n:=l+firstcount;
END
ELSE
BEGIN
Print(380);
p:=l+firstcount-halferrorlin+3;
n:=halferrorlin;
END;
FOR q:=p TO firstcount-1 DO Printchar(trickbuf[q MOD errorline]);
Println;
FOR q:=1 TO n DO Printchar(32);
IF m+n<=errorline THEN
p:=firstcount+m
ELSE
p:=firstcount+(errorline-n-3);
FOR q:=firstcount TO p-1 DO Printchar(trickbuf[q MOD errorline]);
IF m+n>errorline THEN
Print(380);
;
END;
IF(curinput.statefield<>0)THEN
IF(NOT(curinput.namefield=0))OR(baseptr=0)THEN
GOTO 30;
baseptr:=baseptr-1;
END;
30:
curinput:=inputstack[inputptr];
END;
{298}
PROCEDURE Pushinput;
BEGIN
IF inputptr=stacksize THEN
Overflow(381,stacksize);
inputstack[inputptr]:=curinput;
inputptr:=inputptr+1;
END;
{299}
PROCEDURE Popinput;
BEGIN
inputptr:=inputptr-1;
curinput:=inputstack[inputptr];
END;
{300}
PROCEDURE Begintokenli(p:halfword;
t:quarterword);
BEGIN
Pushinput;
curinput.statefield:=0;
curinput.startfield:=p;
curinput.indexfield:=t;
IF t>=4 THEN
BEGIN
mem[p].hh.lh:=mem[p].hh.lh+1;
IF t=4 THEN
curinput.limitfield:=paramptr
ELSE
curinput.locfield:=mem[p]
.hh.rh;
END
ELSE
curinput.locfield:=p;
END;
{301}
PROCEDURE Endtokenlist;
BEGIN
BEGIN
IF interrupt<>0 THEN
Pauseforinst;
END;
IF curinput.indexfield>=3 THEN
BEGIN
IF curinput.indexfield=3 THEN
Flushlist(curinput.startfield)
ELSE
BEGIN
Deletetokenr(curinput.
startfield);
IF curinput.indexfield=4 THEN
WHILE paramptr>curinput.limitfield DO
BEGIN
paramptr:=paramptr-1;
Flushlist(paramstack[paramptr]);
END;
END;
END
ELSE
IF curinput.indexfield=1 THEN
alignstate:=0;
Popinput;
END;
{302}
PROCEDURE Backinput;
VAR
p:halfword;
BEGIN
p:=Getavail;
mem[p].hh.lh:=curtok;
IF curtok<768 THEN
IF curtok<512 THEN
alignstate:=alignstate-1
ELSE
alignstate:=alignstate+1;
Begintokenli(p,3);
END;
{303}
PROCEDURE Backerror;
BEGIN
Backinput;
Error;
END;
{304}
PROCEDURE Beginfilerea;
BEGIN
IF inopen=maxinopen THEN
Overflow(382,maxinopen);
IF first=bufsize THEN
Overflow(128,bufsize);
inopen:=inopen+1;
Pushinput;
curinput.indexfield:=inopen;
linestack[curinput.indexfield]:=line;
curinput.startfield:=first;
END;
{305}
PROCEDURE Endfilereadi;
BEGIN
first:=curinput.startfield;
line:=linestack[curinput.indexfield];
IF NOT(curinput.namefield=0)THEN
Aclose(inputfile[curinput.indexfield]);
Popinput;
inopen:=inopen-1;
END;
{306}
PROCEDURE Clearforerro;
BEGIN
WHILE(curinput.statefield<>0)AND(curinput.namefield=0)
AND(inputptr>0)AND(curinput.locfield=curinput.limitfield)DO
Endfilereadi;
breakin(termin,true);
END;
{312}
PROCEDURE Checkouterva;
VAR
p:halfword;
BEGIN
IF scannerstatu<>0 THEN
IF scannerstatu>1 THEN
{313}
BEGIN
Runaway;
IF csptr=0 THEN
Printnl(388)
ELSE
BEGIN
p:=Getavail;
mem[p].hh.lh:=4096+csptr;
Begintokenli(p,3);
csptr:=0;
curcmd:=10;
curchr:=32;
Printnl(389);
END;
Print(390);
CASE scannerstatu OF
2:Print(391);
3:Print(392);
4:Print(393);
END;
Print(394);
Sprintcs(warningindex);
BEGIN
helpptr:=4;
helpline[3]:=395;
helpline[2]:=396;
helpline[1]:=397;
helpline[0]:=398;
END;
deletionsall:=false;
Error;
deletionsall:=true;
END
ELSE
IF csptr=0 THEN
BEGIN
Printnl(384);
BEGIN
helpptr:=3;
helpline[2]:=385;
helpline[1]:=386;
helpline[0]:=387;
END;
Error;
END;
END;
{314}
PROCEDURE Openerrfile;
FORWARD;
{315}
PROCEDURE Getnext;
LABEL
20,25,21,26,40;
VAR
k:0..bufsize;
t:halfword;
BEGIN
20:
csptr:=0;
IF curinput.statefield<>0 THEN
{317}
BEGIN
25:
IF curinput.locfield<=
curinput.limitfield THEN
BEGIN
curchr:=buffer[curinput.locfield];
curinput.locfield:=curinput.locfield+1;
21:
curcmd:=eqtb[2943+curchr].hh.rh;
{318}
CASE curinput.statefield+curcmd OF
{319}10,26,42,27,43:GOTO 25;
1,17,33:{328}BEGIN
IF curinput.locfield>curinput.limitfield THEN
csptr:=
1
ELSE
BEGIN
26:
k:=curinput.locfield;
curchr:=buffer[k];
k:=k+1;
IF(eqtb[2943+curchr].hh.rh=11)AND(k<=curinput.limitfield)THEN
{330}
BEGIN
REPEAT
curchr:=buffer[k];
k:=k+1;
UNTIL(eqtb[2943+curchr].hh.rh<>11)OR(k>curinput.limitfield);
{329}
BEGIN
IF(buffer[k]=curchr)AND(eqtb[2943+curchr].hh.rh=7)
AND(k<curinput.limitfield)THEN
BEGIN
curchr:=buffer[k+1];
IF(curchr<=95)AND(curchr>=63)THEN
BEGIN
IF curchr>63 THEN
buffer[k-1]:=
curchr-64
ELSE
buffer[k-1]:=127;
curinput.limitfield:=curinput.limitfield-2;
first:=first-2;
WHILE k<=curinput.limitfield DO buffer[k]:=buffer[k+2];
GOTO 26;
END;
END;
END;
IF eqtb[2943+buffer[k-1]].hh.rh<>11 THEN
k:=k-1;
IF k>curinput.locfield+1 THEN
BEGIN
csptr:=Idlookup(curinput.locfield,k-
curinput.locfield);
curinput.locfield:=k;
GOTO 40;
END;
END
ELSE
{329}
BEGIN
IF(buffer[k]=curchr)AND(eqtb[2943+curchr].hh.rh=7)AND
(k<curinput.limitfield)THEN
BEGIN
curchr:=buffer[k+1];
IF(curchr<=95)AND(curchr>=63)THEN
BEGIN
IF curchr>63 THEN
buffer[k-1]:=
curchr-64
ELSE
buffer[k-1]:=127;
curinput.limitfield:=curinput.limitfield-2;
first:=first-2;
WHILE k<=curinput.limitfield DO buffer[k]:=buffer[k+2];
GOTO 26;
END;
END;
END;
csptr:=1+buffer[curinput.locfield];
curinput.locfield:=curinput.locfield+1;
END;
40:
curcmd:=eqtb[csptr].hh.b0;
curchr:=eqtb[csptr].hh.rh;
curinput.statefield:=17;
IF curcmd>=96 THEN
Checkouterva;
END;
14,30,46:{327}BEGIN
csptr:=curchr+129;
curcmd:=eqtb[csptr].hh.b0;
curchr:=eqtb[csptr].hh.rh;
curinput.statefield:=1;
IF curcmd>=96 THEN
Checkouterva;
END;
8,24,40:{326}BEGIN
IF(curchr=buffer[curinput.locfield])
AND(curinput.locfield<curinput.limitfield)THEN
IF(buffer[curinput.locfield+1]<=95)AND
(buffer[curinput.locfield+1]>=63)THEN
BEGIN
IF buffer[curinput.locfield
+1]=63 THEN
curchr:=127
ELSE
curchr:=buffer[curinput.locfield+1]-64;
curinput.locfield:=curinput.locfield+2;
GOTO 21;
END;
curinput.statefield:=1;
END;
16,32,48:{320}BEGIN
Printnl(399);
BEGIN
helpptr:=2;
helpline[1]:=400;
helpline[0]:=401;
END;
GOTO 25;
END;
{321}11:{323}BEGIN
curinput.statefield:=17;
curchr:=32;
END;
6:{322}BEGIN
curinput.statefield:=33;
curinput.locfield:=curinput.limitfield+1;
curcmd:=10;
curchr:=32;
END;
22,15,31,47:{324}BEGIN
curinput.statefield:=33;
curinput.locfield:=curinput.limitfield+1;
GOTO 25;
END;
38:{325}BEGIN
curinput.locfield:=curinput.limitfield+1;
csptr:=parloc;
curcmd:=eqtb[csptr].hh.b0;
curchr:=eqtb[csptr].hh.rh;
IF curcmd>=96 THEN
Checkouterva;
END;
2:alignstate:=alignstate+1;
18,34:BEGIN
curinput.statefield:=1;
alignstate:=alignstate+1;
END;
3:alignstate:=alignstate-1;
19,35:BEGIN
curinput.statefield:=1;
alignstate:=alignstate-1;
END;
20,21,23,25,28,29,36,37,39,41,44,45:curinput.statefield:=1;
OTHERS:
END;
END
ELSE
BEGIN
BEGIN
IF interrupt<>0 THEN
Pauseforinst;
END;
{333}
IF NOT(curinput.namefield=0)THEN
{334}
BEGIN
line:=line+1;
first:=curinput.startfield;
IF Inputln(inputfile[curinput.indexfield])THEN
{335}
BEGIN
IF(eqtb[3611].
int<>0)AND(interaction>1)THEN
BEGIN
Println;
IF curinput.startfield<curinput.limitfield THEN
FOR k:=curinput.
startfield TO curinput.limitfield-1 DO Print(buffer[k]);
first:=curinput.limitfield+1;
BEGIN
Print(404);
Terminput;
END;
IF curinput.limitfield=first THEN
curinput.limitfield:=first-1
ELSE
BEGIN
FOR k:=first TO curinput.limitfield-1 DO
buffer[k+curinput.startfield-first]:=buffer[k];
curinput.limitfield:=curinput.limitfield+curinput.startfield-first;
END;
END;
END
ELSE
IF curinput.limitfield<>curinput.startfield THEN
curinput.
limitfield:=curinput.startfield
ELSE
BEGIN
Checkouterva;
Printchar(41);
Break(termout);
Endfilereadi;
GOTO 20;
END;
buffer[curinput.limitfield]:=13;
first:=curinput.limitfield+1;
curinput.locfield:=curinput.startfield;
END
ELSE
BEGIN
IF inputptr<>0 THEN
BEGIN
Endfilereadi;
GOTO 20;
END;
IF selector<18 THEN
Openerrfile;
IF interaction>1 THEN
BEGIN
IF curinput.limitfield=curinput.startfield
THEN
Printnl(402);
Println;
first:=curinput.startfield;
BEGIN
Print(42);
Terminput;
END;
buffer[curinput.limitfield]:=13;
first:=curinput.limitfield+1;
curinput.locfield:=curinput.startfield;
END
ELSE
Fatalerror(403);
END;
GOTO 25;
END;
END
ELSE
{331}
IF curinput.locfield<>0 THEN
BEGIN
t:=mem[curinput.locfield
].hh.lh;
curinput.locfield:=mem[curinput.locfield].hh.rh;
IF t>=4096 THEN
BEGIN
csptr:=t-4096;
curcmd:=eqtb[csptr].hh.b0;
curchr:=eqtb[csptr].hh.rh;
IF curcmd>=96 THEN
Checkouterva;
END
ELSE
BEGIN
curcmd:=t DIV 256;
curchr:=t MOD 256;
CASE curcmd OF
1:alignstate:=alignstate+1;
2:alignstate:=alignstate-1;
5:{332}BEGIN
Begintokenli(paramstack[curinput.limitfield+curchr-1],0);
GOTO 20;
END;
OTHERS:
END;
END;
END
ELSE
BEGIN
Endtokenlist;
GOTO 20;
END;
IF{316}(alignstate=0)AND(curcmd<=5)AND(curcmd>=4)THEN
{680}
BEGIN
curcmd:=
mem[curalign+5].hh.lh;
mem[curalign+5].hh.lh:=curchr;
IF curcmd=62 THEN
Begintokenli(12011,2)
ELSE
Begintokenli(mem[curalign+2]
.int,2);
alignstate:=1000000;
GOTO 20;
END;
END;
{337}PROCEDURE Gettoken;
BEGIN
nonewcontrol:=false;
Getnext;
nonewcontrol:=true;
IF csptr=0 THEN
BEGIN
IF curcmd=9 THEN
Fatalerror(405);
curtok:=(curcmd*256)+curchr;
END
ELSE
curtok:=4096+csptr;
END;
{338}{347}
PROCEDURE Macrocall;
LABEL
10,22,30,31,40;
VAR
r:halfword;
p:halfword;
q:halfword;
s:halfword;
t:halfword;
u,v:halfword;
rbraceptr:halfword;
n:smallnumber;
unbalance:halfword;
m:halfword;
refcount:halfword;
nonlong:boolean;
savescanners:smallnumber;
savewarningi:halfword;
BEGIN
savescanners:=scannerstatu;
savewarningi:=warningindex;
warningindex:=csptr;
refcount:=curchr;
r:=mem[refcount].hh.rh;
n:=0;
IF eqtb[3613].int<>0 THEN
{359}
BEGIN
Begindiagnos;
Println;
Printcs(warningindex);
Tokenshow(refcount);
Enddiagnosti;
END;
IF mem[r].hh.lh<>3584 THEN
{350}
BEGIN
scannerstatu:=3;
unbalance:=0;
IF(eqtb[csptr].hh.b0=94)OR(eqtb[csptr].hh.b0=96)THEN
nonlong:=true
ELSE
nonlong:=false;
REPEAT
IF(mem[r].hh.lh>=3584)OR(mem[r].hh.lh<3328)THEN
s:=0
ELSE
BEGIN
s
:=mem[r].hh.rh;
r:=s;
p:=12003;
mem[p].hh.rh:=0;
m:=0;
END;
{351}22:
Gettoken;
IF curtok=mem[r].hh.lh THEN
{352}
BEGIN
r:=mem[r].hh.rh;
IF(mem[r].hh.lh>=3328)AND(mem[r].hh.lh<=3584)THEN
BEGIN
IF curtok<512
THEN
alignstate:=alignstate-1;
GOTO 40;
END
ELSE
GOTO 22;
END;
{355}
IF s<>r THEN
IF s=0 THEN
{356}
BEGIN
Printnl(429);
Sprintcs(warningindex);
Print(430);
BEGIN
helpptr:=4;
helpline[3]:=431;
helpline[2]:=432;
helpline[1]:=433;
helpline[0]:=434;
END;
Error;
GOTO 10;
END
ELSE
BEGIN
t:=s;
REPEAT
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=mem[t].hh.lh;
p:=q;
END;
m:=m+1;
u:=mem[t].hh.rh;
v:=s;
WHILE true DO
BEGIN
IF u=r THEN
IF curtok<>mem[v].hh.lh THEN
GOTO 30
ELSE
BEGIN
r:=mem[v].hh.rh;
GOTO 22;
END;
IF mem[u].hh.lh<>mem[v].hh.lh THEN
GOTO 30;
u:=mem[u].hh.rh;
v:=mem[v].hh.rh;
END;
30:
t:=mem[t].hh.rh;
UNTIL t=r;
END;
IF(curtok=partoken)AND nonlong THEN
{354}
BEGIN
Runaway;
Printnl(424);
Sprintcs(warningindex);
Print(425);
BEGIN
helpptr:=3;
helpline[2]:=426;
helpline[1]:=427;
helpline[0]:=428;
END;
pstack[n]:=mem[12003].hh.rh;
alignstate:=alignstate-unbalance;
FOR m:=0 TO n DO Flushlist(pstack[m]);
Backerror;
GOTO 10;
END;
IF curtok<768 THEN
IF curtok<512 THEN
{357}
BEGIN
unbalance:=1;
WHILE true DO
BEGIN
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=curtok;
p:=q;
END;
Gettoken;
IF(curtok=partoken)AND nonlong THEN
{354}
BEGIN
Runaway;
Printnl(424);
Sprintcs(warningindex);
Print(425);
BEGIN
helpptr:=3;
helpline[2]:=426;
helpline[1]:=427;
helpline[0]:=428;
END;
pstack[n]:=mem[12003].hh.rh;
alignstate:=alignstate-unbalance;
FOR m:=0 TO n DO Flushlist(pstack[m]);
Backerror;
GOTO 10;
END;
IF curtok<768 THEN
IF curtok<512 THEN
unbalance:=unbalance+1
ELSE
BEGIN
unbalance:=unbalance-1;
IF unbalance=0 THEN
GOTO 31;
END;
END;
31:
rbraceptr:=p;
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=curtok;
p:=q;
END;
END
ELSE
{353}
BEGIN
Printnl(417);
Sprintcs(warningindex);
Print(418);
BEGIN
helpptr:=5;
helpline[4]:=419;
helpline[3]:=420;
helpline[2]:=421;
helpline[1]:=422;
helpline[0]:=423;
END;
alignstate:=alignstate+1;
nonlong:=true;
Error;
END
ELSE
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=curtok;
p:=q;
END;
m:=m+1;
IF(mem[r].hh.lh<3328)OR(mem[r].hh.lh>3584)THEN
GOTO 22;
40:
IF s<>0 THEN
{358}
BEGIN
IF(m=1)AND(mem[p].hh.lh<768)AND(p<>12003)THEN
BEGIN
mem[rbraceptr].hh.rh:=0;
BEGIN
mem[p].hh.rh:=avail;
avail:=p;
{DYNUSED:=DYNUSED-1;}
END;
p:=mem[12003].hh.rh;
pstack[n]:=mem[p].hh.rh;
BEGIN
mem[p].hh.rh:=avail;
avail:=p;
{DYNUSED:=DYNUSED-1;}
END;
END
ELSE
pstack[n]:=mem[12003].hh.rh;
n:=n+1;
IF eqtb[3613].int<>0 THEN
BEGIN
Begindiagnos;
Printnl(35);
Printint(n);
Print(435);
Tokenshow(pstack[n-1]);
Enddiagnosti;
END;
END;
;
UNTIL mem[r].hh.lh=3584;
END;
{348}
WHILE(curinput.statefield=0)AND(curinput.locfield=0)DO Endtokenlist
;
Begintokenli(refcount,4);
curinput.namefield:=warningindex;
curinput.locfield:=mem[r].hh.rh;
IF n>0 THEN
BEGIN
FOR m:=0 TO n-1 DO paramstack[paramptr+m]:=pstack[m];
paramptr:=paramptr+n;
END;
10:
scannerstatu:=savescanners;
warningindex:=savewarningi;
END;
PROCEDURE Getnctoken;
LABEL
30;
BEGIN
WHILE true DO
BEGIN
Getnext;
IF curcmd<=91 THEN
GOTO 30;
IF curcmd>=94 THEN
Macrocall
ELSE
IF curcmd=93 THEN
{345}
BEGIN
IF curmark
[curchr]<>0 THEN
Begintokenli(curmark[curchr],7);
END
ELSE
{339}
BEGIN
Printnl(406);
BEGIN
helpptr:=5;
helpline[4]:=407;
helpline[3]:=408;
helpline[2]:=409;
helpline[1]:=410;
helpline[0]:=411;
END;
Error;
END;
END;
30:
IF csptr=0 THEN
curtok:=(curcmd*256)+curchr
ELSE
curtok:=4096+csptr;
END;
{340}
PROCEDURE Nctoken;
LABEL
30;
BEGIN
WHILE true DO
BEGIN
IF curcmd<=91 THEN
GOTO 30;
IF curcmd>=94 THEN
Macrocall
ELSE
IF curcmd=93 THEN
{345}
BEGIN
IF curmark
[curchr]<>0 THEN
Begintokenli(curmark[curchr],7);
END
ELSE
{339}
BEGIN
Printnl(406);
BEGIN
helpptr:=5;
helpline[4]:=407;
helpline[3]:=408;
helpline[2]:=409;
helpline[1]:=410;
helpline[0]:=411;
END;
Error;
END;
Getnext;
END;
30:
IF csptr=0 THEN
curtok:=(curcmd*256)+curchr
ELSE
curtok:=4096+csptr;
END;
{361}
PROCEDURE Scanleftbrac;
BEGIN{362}
REPEAT
Getnctoken;
UNTIL curcmd<>10;
IF curcmd<>1 THEN
BEGIN
Printnl(436);
BEGIN
helpptr:=4;
helpline[3]:=437;
helpline[2]:=438;
helpline[1]:=439;
helpline[0]:=440;
END;
Backerror;
curtok:=379;
curcmd:=1;
curchr:=123;
alignstate:=alignstate+1;
END;
END;
{363}
PROCEDURE Scanoptional;
BEGIN{362}
REPEAT
Getnctoken;
UNTIL curcmd<>10;
IF curtok<>3133 THEN
Backinput;
END;
{364}
PROCEDURE Passblock(l:integer);
LABEL
30;
BEGIN
scannerstatu:=1;
WHILE true DO
BEGIN
Gettoken;
IF curcmd=2 THEN
BEGIN
l:=l-1;
IF l<=0 THEN
GOTO 30;
END
ELSE
IF curcmd=1 THEN
l:=l+1;
END;
30:
IF l<0 THEN
BEGIN
alignstate:=alignstate+1;
Printnl(436);
BEGIN
helpptr:=2;
helpline[1]:=441;
helpline[0]:=442;
END;
Error;
END;
scannerstatu:=0;
{365}
BEGIN
Getnctoken;
IF curcmd<>10 THEN
Backinput;
END;
END;
{366}
FUNCTION Scankeyword(s:strnumber):boolean;
LABEL
10;
VAR
p:halfword;
q:halfword;
k:poolpointer;
BEGIN
p:=12005;
mem[p].hh.rh:=0;
k:=strstart[s];
WHILE k<strstart[s+1]DO
BEGIN
Getnctoken;
IF(curcmd=11)AND((curchr=strpool[k])OR(curchr=strpool[k]-32))THEN
BEGIN
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=curtok;
p:=q;
END;
k:=k+1
END
ELSE
BEGIN
Backinput;
IF p<>12005 THEN
Begintokenli(mem[12005].hh.rh,3);
Scankeyword:=false;
GOTO 10;
END;
END;
Flushlist(mem[12005].hh.rh);
Scankeyword:=true;
10:
END;
{367}
PROCEDURE Scanint;
FORWARD;
{384}
PROCEDURE Scansevenbit;
BEGIN
Scanint;
IF(curval<0)OR(curval>127)THEN
BEGIN
Printnl(458);
BEGIN
helpptr:=2;
helpline[1]:=459;
helpline[0]:=460;
END;
Interror(curval);
curval:=0;
END;
END;
{385}
PROCEDURE Scaneightbit;
BEGIN
Scanint;
IF(curval<0)OR(curval>255)THEN
BEGIN
Printnl(461);
BEGIN
helpptr:=2;
helpline[1]:=462;
helpline[0]:=460;
END;
Interror(curval);
curval:=0;
END;
END;
{386}
PROCEDURE Scanfourbiti;
BEGIN
Scanint;
IF(curval<0)OR(curval>15)THEN
BEGIN
Printnl(463);
BEGIN
helpptr:=2;
helpline[1]:=464;
helpline[0]:=460;
END;
Interror(curval);
curval:=0;
END;
END;
{387}
PROCEDURE Scancharnum;
BEGIN
Scanint;
IF(curval<0)OR(curval>255)THEN
BEGIN
Printnl(465);
BEGIN
helpptr:=2;
helpline[1]:=466;
helpline[0]:=460;
END;
Interror(curval);
curval:=0;
END;
END;
{388}
PROCEDURE Scanfifteenb;
BEGIN
Scanint;
IF(curval<0)OR(curval>32767)THEN
BEGIN
Printnl(467);
BEGIN
helpptr:=2;
helpline[1]:=468;
helpline[0]:=460;
END;
Interror(curval);
curval:=0;
END;
END;
{389}
PROCEDURE Scantwentyse;
BEGIN
Scanint;
IF(curval<0)OR(curval>134217727)THEN
BEGIN
Printnl(469);
BEGIN
helpptr:=2;
helpline[1]:=470;
helpline[0]:=460;
END;
Interror(curval);
curval:=0;
END;
END;
{490}
PROCEDURE Scanfontnumb;
VAR
f:internalfont;
BEGIN
Scanint;
IF(curval<0)OR(curval>=badfontcode)THEN
f:=0
ELSE
f:=fontnumber[curval];
IF f=0 THEN
BEGIN
Printnl(558);
BEGIN
helpptr:=3;
helpline[2]:=559;
helpline[1]:=560;
helpline[0]:=561;
END;
Interror(curval);
END;
curval:=f;
END;
{491}
PROCEDURE Scantexinfo(writing:boolean);
VAR
f:internalfont;
BEGIN
Scanfontnumb;
f:=curval;
Scanint;
IF f=0 THEN
curval:=fmemptr
ELSE
BEGIN
IF curval<=0 THEN
curval:=fmemptr
ELSE
BEGIN
IF writing AND(curval<=4)AND(curval>=2)AND(fontglue[f]<>0)
THEN
BEGIN
Deletegluere(fontglue[f]);
fontglue[f]:=0;
END;
IF curval>fontparams[f]THEN
IF f<fontptr THEN
curval:=fmemptr
ELSE
{493}
REPEAT
IF fmemptr=fontmemsize THEN
Overflow(566,fontmemsize);
fontinfo[fmemptr].int:=0;
fmemptr:=fmemptr+1;
fontparams[f]:=fontparams[f]+1;
UNTIL curval=fontparams[f]
ELSE
curval:=curval+parambase[f];
END;
{492}
IF curval=fmemptr THEN
BEGIN
BEGIN
helpptr:=2;
helpline[1]:=562;
helpline[0]:=563;
END;
Printnl(543);
Printint(fontcode[f]);
Print(564);
Printint(fontparams[f]);
Print(565);
Error;
END;
END;
END;
{371}PROCEDURE Scanthe(level:smallnumber;
negative:boolean);
VAR
m:halfword;
BEGIN
Getnctoken;
m:=curchr;
CASE curcmd OF
76:{372}BEGIN
Scansevenbit;
IF m<3876 THEN
BEGIN
curval:=eqtb[m+curval].hh.rh;
curvallevel:=0;
END
ELSE
BEGIN
curval:=eqtb[m+curval].int;
curvallevel:=0;
END;
END;
;
70:{373}IF(level<>4)OR negative THEN
BEGIN
Printnl(449);
BEGIN
helpptr:=1;
helpline[0]:=450;
END;
Backerror;
BEGIN
curval:=0;
curvallevel:=1;
END;
END
ELSE
BEGIN
curval:=eqtb[m].hh.rh;
curvallevel:=4;
END;
71:BEGIN
curval:=eqtb[3583+m].int;
curvallevel:=0;
END;
72,75:BEGIN
curval:=eqtb[4004+m].int;
curvallevel:=1;
END;
73:IF m>=eqtb[2375].hh.rh THEN
BEGIN
curval:=eqtb[2361+m].hh.rh;
curvallevel:=3;
END
ELSE
BEGIN
curval:=eqtb[2361+m].hh.rh;
curvallevel:=2;
END;
69:{376}IF Abs(curlist.modefield)<>m THEN
BEGIN
Printnl(449);
BEGIN
helpptr:=4;
helpline[3]:=453;
helpline[2]:=454;
helpline[1]:=455;
helpline[0]:=450;
END;
Backerror;
BEGIN
curval:=0;
curvallevel:=1;
END;
END
ELSE
BEGIN
curval:=curlist.auxfield;
IF m=1 THEN
curvallevel:=1
ELSE
curvallevel:=0;
END;
79:BEGIN
curval:=eqtb[2942].hh.rh;
curvallevel:=0;
END;
74:{378}BEGIN
Scantexinfo(false);
fontinfo[fmemptr].int:=0;
BEGIN
curval:=fontinfo[curval].int;
curvallevel:=1;
END;
END;
67:{379}BEGIN
Scaneightbit;
CASE m OF
0:curval:=eqtb[3620+curval].int;
1:curval:=eqtb[4022+curval].int;
2:curval:=eqtb[2378+curval].hh.rh;
END;
curvallevel:=m;
END;
68:{377}BEGIN
curval:=0;
IF NOT(curlist.tailfield>12000)AND(curlist.modefield<>0)THEN
BEGIN
IF
mem[curlist.tailfield].hh.b0=9 THEN
curval:=mem[curlist.tailfield+1].hh.
lh;
END
ELSE
IF(curlist.modefield=1)AND(curlist.tailfield=curlist.headfield)
AND(lastpageglue<>65535)THEN
curval:=lastpageglue;
curvallevel:=2;
END;
78:BEGIN
curval:=fontcode[eqtb[2893].hh.rh];
curvallevel:=0;
END;
77:{380}BEGIN
Scanfourbiti;
BEGIN
curval:=fontcode[eqtb[2894+m+curval].hh.rh];
curvallevel:=0;
END;
END;
OTHERS:{381}BEGIN
Printnl(456);
Printcmdchr(curcmd,curchr);
Print(457);
BEGIN
helpptr:=1;
helpline[0]:=450;
END;
Backerror;
BEGIN
curval:=0;
curvallevel:=1;
END;
END
END;
WHILE curvallevel>level DO{382}
BEGIN
IF curvallevel=2 THEN
curval:=mem[
curval+1].int;
curvallevel:=curvallevel-1;
END;
{383}
IF negative THEN
IF curvallevel>=2 THEN
BEGIN
curval:=Newspec(
curval);
{413}
BEGIN
mem[curval+1].int:=-mem[curval+1].int;
mem[curval+2].int:=-mem[curval+2].int;
mem[curval+3].int:=-mem[curval+3].int;
END;
END
ELSE
curval:=-curval
ELSE
IF(curvallevel>=2)AND(curvallevel<>4)THEN
mem[curval].hh.rh:=mem[curval].hh.rh+1;
END;
{391}
PROCEDURE Scanint;
LABEL
30;
VAR
negative:boolean;
m:integer;
d:smallnumber;
vacuous:boolean;
oksofar:boolean;
BEGIN
radix:=0;
oksofar:=true;
{392}negative:=false;
REPEAT{362}
REPEAT
Getnctoken;
UNTIL curcmd<>10;
IF curtok=3117 THEN
BEGIN
negative:=NOT negative;
curtok:=3115;
END;
UNTIL curtok<>3115;
IF curtok=3168 THEN
{393}
BEGIN
Gettoken;
IF curtok<4096 THEN
curval:=curchr
ELSE
IF curtok<4225 THEN
curval:=
curval-4097
ELSE
curval:=curtok-4225;
IF curval>127 THEN
BEGIN
Printnl(471);
BEGIN
helpptr:=2;
helpline[1]:=472;
helpline[0]:=473;
END;
curval:=48;
Backerror;
END
ELSE
{365}
BEGIN
Getnctoken;
IF curcmd<>10 THEN
Backinput;
END;
END
ELSE
IF(curcmd=65)OR(curcmd=67)THEN
{394}
BEGIN
IF curcmd=67 THEN
Backinput
ELSE
IF curchr<>0 THEN
negative:=NOT negative;
Scanthe(0,false);
END
ELSE
{395}
BEGIN
radix:=10;
m:=214748364;
IF curtok=3111 THEN
BEGIN
radix:=8;
m:=268435456;
Getnctoken;
END
ELSE
IF curtok=3106 THEN
BEGIN
radix:=16;
m:=134217728;
Getnctoken;
END;
vacuous:=true;
curval:=0;
{396}
WHILE true DO
BEGIN
IF(curtok<3120+radix)AND(curtok>=3120)AND(
curtok<=3129)THEN
d:=curtok-3120
ELSE
IF(radix=16)AND(curtok<=2886)AND(curtok>=2881)THEN
d:=curtok-2871
ELSE
GOTO 30;
vacuous:=false;
IF(curval>=m)AND((curval>m)OR(d>7)OR(radix<>10))THEN
BEGIN
IF oksofar
THEN
BEGIN
Printnl(474);
BEGIN
helpptr:=2;
helpline[1]:=475;
helpline[0]:=476;
END;
Error;
curval:=2147483647;
oksofar:=false;
END;
END
ELSE
curval:=curval*radix+d;
END;
30:;
IF vacuous THEN
{397}
BEGIN
Printnl(477);
BEGIN
helpptr:=3;
helpline[2]:=478;
helpline[1]:=479;
helpline[0]:=480;
END;
Error;
END
ELSE
IF curcmd<>10 THEN
Backinput;
END;
IF negative THEN
curval:=-curval;
END;
{399}
PROCEDURE Scandimen(mu,inf,shortcut:boolean);
LABEL
30,40,45,88,89;
VAR
negative:boolean;
f:integer;
{401}num,denom:1..65536;
k:smallnumber;
j:smallnumber;
v:scaled;
savecurval:scaled;
BEGIN
f:=0;
aritherror:=false;
curorder:=0;
negative:=false;
IF NOT shortcut THEN
BEGIN{392}
negative:=false;
REPEAT{362}
REPEAT
Getnctoken;
UNTIL curcmd<>10;
IF curtok=3117 THEN
BEGIN
negative:=NOT negative;
curtok:=3115;
END;
UNTIL curtok<>3115;
IF(curcmd=65)OR(curcmd=67)THEN
{400}
BEGIN
IF curcmd=67 THEN
Backinput
ELSE
IF curchr<>0 THEN
negative:=NOT negative;
Scanthe(1,false);
IF curvallevel=1 THEN
GOTO 89;
END
ELSE
BEGIN
IF curtok<>3118 THEN
Scanint
ELSE
BEGIN
Backinput;
radix:=10;
curval:=0;
END;
IF(radix=10)AND(curtok=3118)THEN
{402}
BEGIN
k:=0;
Gettoken;
WHILE true DO
BEGIN
Getnctoken;
IF(curtok>3129)OR(curtok<3120)THEN
GOTO 30;
IF k<16 THEN
BEGIN
dig[k]:=curtok-3120;
k:=k+1;
END;
END;
30:
f:=Rounddecimal(k);
Backinput;
END;
END;
END;
IF curval<0 THEN
BEGIN
negative:=NOT negative;
curval:=-curval;
END;
{403}
IF inf THEN
{404}
IF Scankeyword(173)THEN
BEGIN
curorder:=1;
WHILE Scankeyword(108)DO
BEGIN
IF curorder=3 THEN
BEGIN
BEGIN
helpptr:=1
;
helpline[0]:=483;
END;
Printnl(484);
Print(485);
Error;
END
ELSE
curorder:=curorder+1;
END;
GOTO 89;
END;
IF mu THEN
{405}
IF Scankeyword(194)THEN
GOTO 88
ELSE
BEGIN
Printnl(484);
Print(486);
BEGIN
helpptr:=4;
helpline[3]:=487;
helpline[2]:=488;
helpline[1]:=489;
helpline[0]:=490;
END;
Error;
GOTO 88;
END;
{406}
IF Scankeyword(491)THEN
BEGIN
v:={471}fontinfo[6+parambase[eqtb[
2893].hh.rh]].int;
GOTO 40;
END;
IF Scankeyword(492)THEN
BEGIN
v:={472}fontinfo[5+parambase[eqtb[2893].hh
.rh]].int;
GOTO 40;
END;
IF Scankeyword(493)THEN
BEGIN
v:=eqtb[4006].int;
GOTO 40;
END;
IF Scankeyword(494)THEN
j:=1
ELSE
IF Scankeyword(495)THEN
j:=2
ELSE
IF
Scankeyword(496)THEN
j:=3
ELSE
GOTO 45;
savecurval:=curval;
Scaneightbit;
IF eqtb[2637+curval].hh.rh=0 THEN
v:=0
ELSE
v:=mem[eqtb[2637+curval].hh.
rh+j].int;
curval:=savecurval;
40:
curval:=Nxplusy(curval,v,Xnoverd(v,f,65536));
GOTO 89;
45:;
IF Scankeyword(481)THEN
{407}
BEGIN{365}
BEGIN
Getnctoken;
IF curcmd<>10 THEN
Backinput;
END;
Preparemag;
IF eqtb[3600].int<>1000 THEN
BEGIN
curval:=Xnoverd(curval,1000,eqtb[3600
].int);
f:=(1000*f+65536*remainder)DIV eqtb[3600].int;
curval:=curval+(f DIV 65536);
f:=f MOD 65536;
END;
END;
IF Scankeyword(482)THEN
GOTO 88;
{408}
IF Scankeyword(497)THEN
BEGIN
num:=7227;
denom:=100;
END
ELSE
IF Scankeyword(498)THEN
BEGIN
num:=12;
denom:=1;
END
ELSE
IF Scankeyword(499)THEN
BEGIN
num:=7227;
denom:=254;
END
ELSE
IF Scankeyword(500)THEN
BEGIN
num:=7227;
denom:=2540;
END
ELSE
IF Scankeyword(501)THEN
BEGIN
num:=7227;
denom:=7200;
END
ELSE
IF Scankeyword(502)THEN
BEGIN
num:=215;
denom:=201;
END
ELSE
IF Scankeyword(503)THEN
BEGIN
num:=2580;
denom:=201;
END
ELSE
IF Scankeyword(504)THEN
GOTO 89
ELSE
{409}
BEGIN
Printnl(484);
Print(505);
BEGIN
helpptr:=6;
helpline[5]:=506;
helpline[4]:=507;
helpline[3]:=508;
helpline[2]:=488;
helpline[1]:=489;
helpline[0]:=490;
END;
Error;
GOTO 88;
END;
curval:=Xnoverd(curval,num,denom);
f:=(num*f+65536*remainder)DIV denom;
curval:=curval+(f DIV 65536);
f:=f MOD 65536;
88:
IF curval>=16384 THEN
aritherror:=true
ELSE
curval:=curval*65536+f;
89:
IF negative THEN
curval:=-curval;
IF aritherror OR(Abs(curval)>=1073741824)THEN
{410}
BEGIN
Printnl(509);
BEGIN
helpptr:=2;
helpline[1]:=510;
helpline[0]:=511;
END;
Error;
curval:=134217727;
END;
{365}
BEGIN
Getnctoken;
IF curcmd<>10 THEN
Backinput;
END;
END;
{411}
PROCEDURE Scanglue(mu:boolean);
VAR
negative:boolean;
q:halfword;
BEGIN{392}
negative:=false;
REPEAT{362}
REPEAT
Getnctoken;
UNTIL curcmd<>10;
IF curtok=3117 THEN
BEGIN
negative:=NOT negative;
curtok:=3115;
END;
UNTIL curtok<>3115;
IF(curcmd=65)OR(curcmd=67)THEN
BEGIN
IF curcmd=67 THEN
Backinput
ELSE
IF
curchr<>0 THEN
negative:=NOT negative;
Scanthe(2,negative);
negative:=false;
IF curval=2 THEN
GOTO 10;
IF curval=0 THEN
Scandimen(mu,false,true);
END
ELSE
Scandimen(mu,false,false);
{412}q:=Newspec(0);
mem[q+1].int:=curval;
IF Scankeyword(512)THEN
BEGIN
Scandimen(mu,true,false);
mem[q+2].int:=curval;
mem[q].hh.b0:=curorder;
END;
IF Scankeyword(448)THEN
BEGIN
Scandimen(mu,true,false);
mem[q+3].int:=curval;
mem[q].hh.b1:=curorder;
END;
curval:=q;
IF negative THEN
{413}
BEGIN
mem[curval+1].int:=-mem[curval+1].int;
mem[curval+2].int:=-mem[curval+2].int;
mem[curval+3].int:=-mem[curval+3].int;
END;
10:
END;
{414}
FUNCTION Scanrulespec:halfword;
LABEL
21;
VAR
q:halfword;
BEGIN
q:=Newrule;
IF curcmd=35 THEN
mem[q+1].int:=26215
ELSE
BEGIN
mem[q+3].int:=26215;
mem[q+2].int:=0;
END;
21:
IF Scankeyword(513)THEN
BEGIN
Scandimen(false,false,false);
mem[q+1].int:=curval;
GOTO 21;
END;
IF Scankeyword(514)THEN
BEGIN
Scandimen(false,false,false);
mem[q+3].int:=curval;
GOTO 21;
END;
IF Scankeyword(515)THEN
BEGIN
Scandimen(false,false,false);
mem[q+2].int:=curval;
GOTO 21;
END;
Scanrulespec:=q;
END;
{415}
FUNCTION Strtoks:halfword;
VAR
p:halfword;
q:halfword;
t:halfword;
k:poolpointer;
BEGIN
BEGIN
IF poolptr+1>poolsize THEN
Overflow(129,poolsize);
END;
p:=12003;
mem[p].hh.rh:=0;
k:=strstart[strptr];
WHILE k<poolptr DO
BEGIN
t:=strpool[k];
IF t=32 THEN
t:=2592
ELSE
IF t>=97 THEN
t:=2816+t
ELSE
t:=3072+t;
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=t;
p:=q;
END;
k:=k+1;
END;
poolptr:=strstart[strptr];
Strtoks:=p;
END;
{416}
FUNCTION Thetoks(negative:boolean):halfword;
VAR
oldsetting:0..21;
p,q,r:halfword;
BEGIN
Scanthe(4,negative);
IF curvallevel=4 THEN
{417}
BEGIN
r:=mem[curval].hh.rh;
p:=12003;
mem[p].hh.rh:=0;
WHILE r<>0 DO
BEGIN
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=mem[r].hh.lh;
p:=q;
END;
r:=mem[r].hh.rh;
END;
Thetoks:=p;
END
ELSE
BEGIN
oldsetting:=selector;
selector:=21;
CASE curvallevel OF
0:Printint(curval);
1:BEGIN
Printscaled(curval);
Print(482);
END;
2:BEGIN
Printspec(curval,482);
Deletegluere(curval);
END;
3:BEGIN
Printspec(curval,194);
Deletegluere(curval);
END;
END;
selector:=oldsetting;
Thetoks:=Strtoks;
END;
END;
{418}
FUNCTION Numtoks:halfword;
VAR
oldsetting:0..21;
BEGIN
oldsetting:=selector;
Scanint;
selector:=21;
IF curval>=0 THEN
Printint(curval)
ELSE
Printromanin(-curval);
selector:=oldsetting;
Numtoks:=Strtoks;
END;
{419}
FUNCTION Scantoks(macrodef,xpand:boolean):halfword;
LABEL
40,30,31,32;
VAR
r:halfword;
t:halfword;
s:halfword;
p:halfword;
q:halfword;
unbalance:halfword;
BEGIN
scannerstatu:=2;
warningindex:=csptr;
r:=Getavail;
p:=r;
IF macrodef THEN
{420}
BEGIN
t:=3120;
WHILE true DO
BEGIN
Gettoken;
IF curcmd<=2 THEN
GOTO 31;
IF curcmd=6 THEN
{422}
BEGIN
s:=3328+curchr;
Gettoken;
IF curcmd=1 THEN
BEGIN
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=curtok;
p:=q;
END;
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=3584;
p:=q;
END;
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=curtok;
p:=q;
END;
GOTO 30;
END;
IF t=3129 THEN
BEGIN
Printnl(518);
BEGIN
helpptr:=1;
helpline[0]:=519;
END;
Error;
END
ELSE
BEGIN
t:=t+1;
IF curtok<>t THEN
BEGIN
Printnl(520);
BEGIN
helpptr:=2;
helpline[1]:=521;
helpline[0]:=522;
END;
Backerror;
END;
curtok:=s;
END;
END;
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=curtok;
p:=q;
END;
END;
31:
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=3584;
p:=q;
END;
IF curcmd=2 THEN
{421}
BEGIN
Printnl(436);
alignstate:=alignstate+1;
BEGIN
helpptr:=2;
helpline[1]:=516;
helpline[0]:=517;
END;
Error;
GOTO 40;
END;
30:
END
ELSE
Scanleftbrac;
{423}unbalance:=1;
WHILE true DO
BEGIN
IF xpand AND(curcmd<>82)THEN
{424}
BEGIN
WHILE true DO
BEGIN
Getnctoken;
IF curcmd=65 THEN
q:=Thetoks(curchr>0)
ELSE
IF curcmd=66 THEN
q:=Numtoks
ELSE
GOTO 32;
mem[p].hh.rh:=mem[12003].hh.rh;
p:=q;
END;
32:
END
ELSE
Gettoken;
IF curcmd<=2 THEN
IF curcmd<2 THEN
unbalance:=unbalance+1
ELSE
BEGIN
unbalance:=unbalance-1;
IF unbalance=0 THEN
GOTO 40;
END
ELSE
IF curcmd=6 THEN
{425}
BEGIN
s:=curtok;
Gettoken;
IF curcmd<>6 THEN
IF(curchr<49)OR(curchr>t-3072)OR(curcmd<>12)THEN
BEGIN
Printnl(523);
Sprintcs(warningindex);
BEGIN
helpptr:=3;
helpline[2]:=524;
helpline[1]:=525;
helpline[0]:=526;
END;
Backerror;
curtok:=s;
END
ELSE
curtok:=1232+curchr;
END;
BEGIN
q:=Getavail;
mem[p].hh.rh:=q;
mem[q].hh.lh:=curtok;
p:=q;
END;
END;
40:
scannerstatu:=0;
curval:=r;
Scantoks:=p;
END;
{430}PROCEDURE Beginname;
BEGIN
areadelimite:=0;
extdelimiter:=0;
END;
{431}
FUNCTION Morename(c:asciicode):boolean;
BEGIN
IF c=32 THEN
Morename:=false
ELSE
BEGIN
IF(c=62)OR(c=58)THEN
BEGIN
areadelimite:=poolptr;
extdelimiter:=0;
END
ELSE
IF(c=46)AND(extdelimiter=0)THEN
extdelimiter:=poolptr;
BEGIN
IF poolptr+1>poolsize THEN
Overflow(129,poolsize);
END;
BEGIN
strpool[poolptr]:=c;
poolptr:=poolptr+1;
END;
Morename:=true;
END;
END;
{432}
PROCEDURE Endname;
BEGIN
IF strptr+3>maxstrings THEN
Overflow(130,maxstrings);
IF areadelimite=0 THEN
curarea:=529
ELSE
BEGIN
curarea:=strptr;
strptr:=strptr+1;
strstart[strptr]:=areadelimite+1;
END;
IF extdelimiter=0 THEN
BEGIN
curext:=529;
curname:=Makestring;
END
ELSE
BEGIN
curname:=strptr;
strptr:=strptr+1;
strstart[strptr]:=extdelimiter;
curext:=Makestring;
END;
END;
{434}
PROCEDURE Packfilename(n,a,e:strnumber);
VAR
k:integer;
c:asciicode;
j:poolpointer;
BEGIN
IF(strstart[a+1]-strstart[a])+(strstart[n+1]-strstart[n])+(
strstart[e+1]-strstart[e])>filenamesize THEN
Overflow(530,filenamesize);
k:=0;
FOR j:=strstart[a]TO strstart[a+1]-1 DO
BEGIN
c:=strpool[j];
k:=k+1;
IF(c>=97)AND(c<=122)THEN
c:=c-32;
nameoffile[k]:=xchr[c];
END;
FOR j:=strstart[n]TO strstart[n+1]-1 DO
BEGIN
c:=strpool[j];
k:=k+1;
IF(c>=97)AND(c<=122)THEN
c:=c-32;
nameoffile[k]:=xchr[c];
END;
FOR j:=strstart[e]TO strstart[e+1]-1 DO
BEGIN
c:=strpool[j];
k:=k+1;
IF(c>=97)AND(c<=122)THEN
c:=c-32;
nameoffile[k]:=xchr[c];
END;
namelength:=k;
FOR k:=namelength+1 TO filenamesize DO nameoffile[k]:=' ';
END;
{438}
PROCEDURE Packbuffered(n:smallnumber;
a,b:integer);
VAR
k:integer;
c:asciicode;
j:integer;
BEGIN
IF n+b-a+5>filenamesize THEN
b:=a+filenamesize-n-5;
k:=0;
FOR j:=1 TO n DO
BEGIN
c:=xord[texformatdef[j]];
k:=k+1;
IF(c>=97)AND(c<=122)THEN
c:=c-32;
nameoffile[k]:=xchr[c];
END;
FOR j:=a TO b DO
BEGIN
c:=buffer[j];
k:=k+1;
IF(c>=97)AND(c<=122)THEN
c:=c-32;
nameoffile[k]:=xchr[c];
END;
FOR j:=19 TO 22 DO
BEGIN
c:=xord[texformatdef[j]];
k:=k+1;
IF(c>=97)AND(c<=122)THEN
c:=c-32;
nameoffile[k]:=xchr[c];
END;
namelength:=k;
FOR k:=namelength+1 TO filenamesize DO nameoffile[k]:=' ';
END;
{440}
FUNCTION Makenamestri:strnumber;
VAR
k:1..filenamesize;
BEGIN
BEGIN
IF poolptr+namelength>poolsize THEN
Overflow(129,poolsize);
END;
FOR k:=1 TO namelength DO
BEGIN
strpool[poolptr]:=xord[nameoffile[k]];
poolptr:=poolptr+1;
END;
Makenamestri:=Makestring;
END;
FUNCTION Amakenamestr(VAR f:alphafile):strnumber;
BEGIN
Amakenamestr:=Makenamestri;
END;
FUNCTION Bmakenamestr(VAR f:bytefile):strnumber;
BEGIN
Bmakenamestr:=Makenamestri;
END;
FUNCTION Wmakenamestr(VAR f:wordfile):strnumber;
BEGIN
Wmakenamestr:=Makenamestri;
END;
{441}
PROCEDURE Writenamestr;
VAR
k:1..filenamesize;
BEGIN
FOR k:=1 TO namelength DO Write(termout,nameoffile[k]);
END;
{442}
PROCEDURE Scanfilename;
LABEL
30;
BEGIN
Beginname;
{362}
REPEAT
Getnctoken;
UNTIL curcmd<>10;
WHILE true DO
BEGIN
IF(curcmd>12)OR(curchr>127)THEN
BEGIN
Backinput;
GOTO 30;
END;
IF NOT Morename(curchr)THEN
GOTO 30;
Getnctoken;
END;
30:
Endname;
END;
{445}
PROCEDURE Packjobname(s:strnumber);
BEGIN
curarea:=529;
curext:=s;
IF jobname=0 THEN
jobname:=531;
curname:=jobname;
Packfilename(curname,curarea,curext);
END;
{446}
PROCEDURE Promptfilena(s,e:strnumber);
LABEL
30;
VAR
k:0..bufsize;
BEGIN
IF s=532 THEN
Printnl(533)
ELSE
Printnl(534);
Printfilenam(curname,curarea,curext);
Printchar(46);
IF e=535 THEN
Showcontext;
Printnl(536);
Print(s);
IF interaction<2 THEN
Fatalerror(537);
breakin(termin,true);
BEGIN
Print(538);
Terminput;
END;
{447}
BEGIN
Beginname;
k:=first;
WHILE(buffer[k]=32)AND(k<curinput.limitfield)DO k:=k+1;
WHILE true DO
BEGIN
IF k=curinput.limitfield THEN
GOTO 30;
IF NOT Morename(buffer[k])THEN
GOTO 30;
k:=k+1;
END;
30:
Endname;
END;
IF curext=529 THEN
curext:=e;
Packfilename(curname,curarea,curext);
END;
{450}
PROCEDURE Openerrfile;
VAR
oldsetting:0..21;
k:0..bufsize;
months:PACKED ARRAY[1..36]OF char;
BEGIN
oldsetting:=selector;
Packjobname(541);
WHILE NOT Aopenout(errfile)DO Promptfilena(542,541);
selector:=18;
{451}
BEGIN
Write(errfile,'This is TeX, Version 0');
Print(formatident);
Printint(eqtb[3604].int);
Printchar(32);
months:='JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC';
FOR k:=3*eqtb[3605].int-2 TO 3*eqtb[3605].int DO Write(errfile,months[k]
);
Printchar(32);
Printint(eqtb[3606].int);
Printchar(32);
Printint(eqtb[3603].int DIV 60);
Printchar(58);
Printchar(48+((eqtb[3603].int MOD 60)DIV 10));
Printchar(48+(eqtb[3603].int MOD 10));
Println;
END;
inputstack[inputptr]:=curinput;
FOR k:=1 TO inputstack[0].limitfield DO Print(buffer[k-1]);
Println;
selector:=oldsetting+2;
END;
{452}
PROCEDURE Startinput;
LABEL
30;
BEGIN
Scanfilename;
IF curext=529 THEN
curext:=535;
Packfilename(curname,curarea,curext);
Beginfilerea;
WHILE true DO
BEGIN
IF Aopenin(inputfile[curinput.indexfield])THEN
GOTO
30;
Packfilename(curname,527,curext);
IF Aopenin(inputfile[curinput.indexfield])THEN
GOTO 30;
Promptfilena(532,535);
END;
30:
curinput.namefield:=Amakenamestr(inputfile[curinput.indexfield]);
IF jobname=0 THEN
BEGIN
jobname:=curname;
Openerrfile;
END;
Print(149);
Print(curinput.namefield);
Break(termout);
{453}
BEGIN
IF Eoln(inputfile[curinput.indexfield])THEN
curinput.
limitfield:=curinput.startfield
ELSE
BEGIN
buffer[curinput.startfield]:=
xord[inputfile[curinput.indexfield]↑];
first:=curinput.startfield+1;
IF NOT Inputln(inputfile[curinput.indexfield])THEN
Confusion(311);
END;
buffer[curinput.limitfield]:=13;
first:=curinput.limitfield+1;
curinput.locfield:=curinput.startfield;
line:=1;
END;
END;
{473}PROCEDURE Readfontinfo(u:userfontcode;
nom,aire:strnumber;
s:scaled);
LABEL
30,11,45;
VAR
k:0..fontmemsize;
fileopened:boolean;
lf,lh,bc,ec,nw,nh,nd,ni,nl,nk,ne,np:halfword;
f:internalfont;
a,b,c,d:eightbits;
qw:fourquarters;
sw:scaled;
z:scaled;
alpha:16..256;
beta:1..16;
BEGIN{475}{476}
fileopened:=false;
IF aire=529 THEN Packfilename(nom,528,552)
ELSE Packfilename(nom,aire,552);
IF NOT Bopenin(tfmfile)THEN GOTO 11;
fileopened:=true;
{478}
BEGIN
BEGIN
lf:=tfmfile↑;
IF lf>127 THEN GOTO 11;
Get(tfmfile);
lf:=lf*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
lh:=tfmfile↑;
IF lh>127 THEN GOTO 11;
Get(tfmfile);
lh:=lh*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
bc:=tfmfile↑;
IF bc>127 THEN GOTO 11;
Get(tfmfile);
bc:=bc*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
ec:=tfmfile↑;
IF ec>127 THEN GOTO 11;
Get(tfmfile);
ec:=ec*256+tfmfile↑;
END;
IF(bc>ec+1)OR(ec>255)THEN GOTO 11;
Get(tfmfile);
BEGIN
nw:=tfmfile↑;
IF nw>127 THEN GOTO 11;
Get(tfmfile);
nw:=nw*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
nh:=tfmfile↑;
IF nh>127 THEN GOTO 11;
Get(tfmfile);
nh:=nh*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
nd:=tfmfile↑;
IF nd>127 THEN GOTO 11;
Get(tfmfile);
nd:=nd*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
ni:=tfmfile↑;
IF ni>127 THEN GOTO 11;
Get(tfmfile);
ni:=ni*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
nl:=tfmfile↑;
IF nl>127 THEN GOTO 11;
Get(tfmfile);
nl:=nl*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
nk:=tfmfile↑;
IF nk>127 THEN GOTO 11;
Get(tfmfile);
nk:=nk*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
ne:=tfmfile↑;
IF ne>127 THEN GOTO 11;
Get(tfmfile);
ne:=ne*256+tfmfile↑;
END;
Get(tfmfile);
BEGIN
np:=tfmfile↑;
IF np>127 THEN GOTO 11;
Get(tfmfile);
np:=np*256+tfmfile↑;
END;
IF lf<>6+lh+(ec-bc+1)+nw+nh+nd+ni+nl+nk+ne+np THEN GOTO 11;
END;
{479}lf:=lf-6-lh;
IF np<7 THEN lf:=lf+7-np;
IF(fontptr=fontmax)OR(fmemptr+lf>fontmemsize)THEN
{480}
BEGIN
Printnl(543);
Printint(u);
Printchar(61);
Printfilenam(nom,aire,529);
IF s<>0 THEN
BEGIN
Print(544);
Printscaled(s);
Print(482);
END;
Print(553);
BEGIN
helpptr:=4;
helpline[3]:=554;
helpline[2]:=555;
helpline[1]:=556;
helpline[0]:=557;
END;
Error;
GOTO 30;
END;
f:=fontptr+1;
charbase[f]:=fmemptr-bc;
widthbase[f]:=charbase[f]+ec+1;
heightbase[f]:=widthbase[f]+nw;
depthbase[f]:=heightbase[f]+nh;
italicbase[f]:=depthbase[f]+nd;
ligkernbase[f]:=italicbase[f]+ni;
kernbase[f]:=ligkernbase[f]+nl;
extenbase[f]:=kernbase[f]+nk;
parambase[f]:=extenbase[f]+ne;;
{481}
BEGIN
IF lh<2 THEN GOTO 11;
BEGIN
Get(tfmfile);
a:=tfmfile↑;
qw.b0:=(a+0);
Get(tfmfile);
b:=tfmfile↑;
qw.b1:=(b+0);
Get(tfmfile);
c:=tfmfile↑;
qw.b2:=(c+0);
Get(tfmfile);
d:=tfmfile↑;
qw.b3:=(d+0);
fontcheck[f]:=qw;
END;
Get(tfmfile);
BEGIN
z:=tfmfile↑;
IF z>127 THEN GOTO 11;
Get(tfmfile);
z:=z*256+tfmfile↑;
END;
Get(tfmfile);
z:=z*256+tfmfile↑;
Get(tfmfile);
z:=(z*16)+(tfmfile↑DIV 16);
IF z<65536 THEN GOTO 11;
WHILE lh>2 DO
BEGIN
Get(tfmfile);
Get(tfmfile);
Get(tfmfile);
Get(tfmfile);
lh:=lh-1;
END;
IF s=0 THEN fontscaled[f]:=false
ELSE
IF z=s THEN fontscaled[f]:=false
ELSE
BEGIN
fontscaled[f]:=true;
z:=s;
END;
fontsize[f]:=z;
END;
{482}
FOR k:=fmemptr TO widthbase[f]-1 DO
BEGIN
BEGIN
Get(tfmfile);
a:=tfmfile↑;
qw.b0:=(a+0);
Get(tfmfile);
b:=tfmfile↑;
qw.b1:=(b+0);
Get(tfmfile);
c:=tfmfile↑;
qw.b2:=(c+0);
Get(tfmfile);
d:=tfmfile↑;
qw.b3:=(d+0);
fontinfo[k].qqqq:=qw;
END;
IF(a>=nw)OR(b DIV 16>=nh)OR(b MOD 16>=nd)OR(c DIV 4>=ni)THEN
GOTO 11;
CASE c MOD 4 OF
1:IF d>=nl THEN GOTO 11;
3:IF d>=ne THEN GOTO 11;
2:{483}BEGIN
BEGIN
IF(d<bc)OR(d>ec)THEN GOTO 11
END;
WHILE d<k+bc-fmemptr DO
BEGIN
qw:=fontinfo[charbase[f]+d].qqqq;
IF((qw.b2-0)MOD 4)<>2 THEN GOTO 45;
d:=(qw.b3-0);
END;
IF d=k+bc-fmemptr THEN GOTO 11;
45:
END;
OTHERS:
END;
END;
{484}
BEGIN{485}
BEGIN
alpha:=16*z;
beta:=16;
WHILE z>=8388608 DO
BEGIN
z:=z DIV 2;
beta:=beta DIV 2;
END;
END;
FOR k:=widthbase[f]TO ligkernbase[f]-1 DO
BEGIN
Get(tfmfile);
a:=tfmfile↑;
Get(tfmfile);
b:=tfmfile↑;
Get(tfmfile);
c:=tfmfile↑;
Get(tfmfile);
d:=tfmfile↑;
sw:=(((((d*z)DIV 256)+(c*z))DIV 256)+(b*z))DIV beta;
IF a=0 THEN
fontinfo[k].int:=sw
ELSE
IF a=255 THEN fontinfo[k].int:=sw-alpha ELSE GOTO 11;
END;
IF fontinfo[widthbase[f]].int<>0 THEN GOTO 11;
IF fontinfo[heightbase[f]].int<>0 THEN GOTO 11;
IF fontinfo[depthbase[f]].int<>0 THEN GOTO 11;
IF fontinfo[italicbase[f]].int<>0 THEN GOTO 11;
END;
{486}
BEGIN
FOR k:=ligkernbase[f]TO kernbase[f]-1 DO
BEGIN
BEGIN
Get(
tfmfile);
a:=tfmfile↑;
qw.b0:=(a+0);
Get(tfmfile);
b:=tfmfile↑;
qw.b1:=(b+0);
Get(tfmfile);
c:=tfmfile↑;
qw.b2:=(c+0);
Get(tfmfile);
d:=tfmfile↑;
qw.b3:=(d+0);
fontinfo[k].qqqq:=qw;
END;
BEGIN
IF(b<bc)OR(b>ec)THEN GOTO 11
END;
IF c<128 THEN
BEGIN
IF(d<bc)OR(d>ec)THEN GOTO 11
END
ELSE IF d>=nk THEN GOTO 11;
END;
IF(nl>0)AND(a<128)THEN GOTO 11;
FOR k:=kernbase[f]TO extenbase[f]-1 DO
BEGIN
Get(tfmfile);
a:=tfmfile↑;
Get(tfmfile);
b:=tfmfile↑;
Get(tfmfile);
c:=tfmfile↑;
Get(tfmfile);
d:=tfmfile↑;
sw:=(((((d*z)DIV 256)+(c*z))DIV 256)+(b*z))DIV beta;
IF a=0 THEN fontinfo[k].int:=sw
ELSE
IF a=255 THEN fontinfo[k].int:=sw-alpha
ELSE GOTO 11;
END;
END;
{487}
FOR k:=extenbase[f]TO parambase[f]-1 DO
BEGIN
BEGIN
Get(tfmfile);
a:=tfmfile↑;
qw.b0:=(a+0);
Get(tfmfile);
b:=tfmfile↑;
qw.b1:=(b+0);
Get(tfmfile);
c:=tfmfile↑;
qw.b2:=(c+0);
Get(tfmfile);
d:=tfmfile↑;
qw.b3:=(d+0);
fontinfo[k].qqqq:=qw;
END;
IF a<>0 THEN
BEGIN
IF(a<bc)OR(a>ec)THEN GOTO 11
END;
IF b<>0 THEN
BEGIN
IF(b<bc)OR(b>ec)THEN GOTO 11
END;
IF c<>0 THEN
BEGIN
IF(c<bc)OR(c>ec)THEN GOTO 11
END;
BEGIN
IF(d<bc)OR(d>ec)THEN GOTO 11
END;
END;
{488}
BEGIN
FOR k:=1 TO np DO
IF k=1 THEN
BEGIN
Get(tfmfile);
sw:=tfmfile↑;
IF sw>127 THEN
sw:=sw-256;
Get(tfmfile);
sw:=sw*256+tfmfile↑;
Get(tfmfile);
sw:=sw*256+tfmfile↑;
Get(tfmfile);
fontinfo[parambase[f]].int:=(sw*16)+(tfmfile↑DIV 16);
END
ELSE
BEGIN
Get(tfmfile);
a:=tfmfile↑;
Get(tfmfile);
b:=tfmfile↑;
Get(tfmfile);
c:=tfmfile↑;
Get(tfmfile);
d:=tfmfile↑;
sw:=(((((d*z)DIV 256)+(c*z))DIV 256)+(b*z))DIV beta;
IF a=0 THEN fontinfo[parambase[f]+k-1].int:=sw
ELSE
IF a=255 THEN fontinfo[parambase[f]+k-1].int:=sw-alpha
ELSE GOTO 11;
END;
IF Eof(tfmfile)THEN GOTO 11;
FOR k:=np+1 TO 7 DO fontinfo[parambase[f]+k-1].int:=0;
END;
{489}fontcode[f]:=u;
fontnumber[u]:=f;
IF np>=7 THEN fontparams[f]:=np
ELSE fontparams[f]:=7;
fontname[f]:=nom;
fontarea[f]:=aire;
fontbc[f]:=bc;
fontec[f]:=ec;
fontglue[f]:=0;
charbase[f]:=(charbase[f]-0);
widthbase[f]:=(widthbase[f]-0);
ligkernbase[f]:=(ligkernbase[f]-0);
kernbase[f]:=(kernbase[f]-0);
extenbase[f]:=(extenbase[f]-0);
parambase[f]:=parambase[f]-1;
fmemptr:=fmemptr+lf;
fontptr:=f;
GOTO 30;;
11:{474}
Printnl(543);
Printint(u);
Printchar(61);
Printfilenam(nom,aire,529);
IF s<>0 THEN
BEGIN
Print(544);
Printscaled(s);
Print(482);
END;
IF fileopened THEN
Print(545)
ELSE
Print(546);
BEGIN
helpptr:=5;
helpline[4]:=547;
helpline[3]:=548;
helpline[2]:=549;
helpline[1]:=550;
helpline[0]:=551;
END;
Error;;
30:
Bclose(tfmfile);
END;
{494}PROCEDURE Charwarning(f:internalfont;
c:eightbits);
BEGIN
IF eqtb[3616].int<>0 THEN
BEGIN
Begindiagnos;
Printnl(567);
Printascii(c);
Print(568);
Print(fontname[f]);
Printchar(33);
Enddiagnosti;
END;
END;
{495}
FUNCTION Newcharacter(f:internalfont;
c:eightbits):halfword;
LABEL
10;
VAR
p:halfword;
BEGIN
IF(fontbc[f]<=c)AND(fontec[f]>=c)THEN
IF(fontinfo[charbase[f]+(c+0
)].qqqq.b0>0)THEN
BEGIN
p:=Getavail;
mem[p].hh.b0:=f;
mem[p].hh.b1:=(c+0);
Newcharacter:=p;
GOTO 10;
END;
Charwarning(f,c);
Newcharacter:=0;
10:
END;
{508}PROCEDURE Writedvi(a,b:dviindex);
VAR
k:dviindex;
BEGIN
FOR k:=a TO b DO Write(dvifile,dvibuf[k]);
END;
{509}
PROCEDURE Dviswap;
BEGIN
IF dvilimit=dvibufsize THEN
BEGIN
Writedvi(0,halfbuf-1);
dvilimit:=halfbuf;
dvioffset:=dvioffset+dvibufsize;
dviptr:=0;
END
ELSE
BEGIN
Writedvi(halfbuf,dvibufsize-1);
dvilimit:=dvibufsize;
END;
dvigone:=dvigone+halfbuf;
END;
{511}
PROCEDURE Dvifour(x:integer);
BEGIN
IF x>=0 THEN
BEGIN
dvibuf[dviptr]:=x DIV 16777216;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END
ELSE
BEGIN
x:=x+1073741824;
x:=x+1073741824;
BEGIN
dvibuf[dviptr]:=(x DIV 16777216)+128;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
END;
x:=x MOD 16777216;
BEGIN
dvibuf[dviptr]:=x DIV 65536;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
x:=x MOD 65536;
BEGIN
dvibuf[dviptr]:=x DIV 256;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
BEGIN
dvibuf[dviptr]:=x MOD 256;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
END;
{515}
PROCEDURE Movement(w:scaled;
o:eightbits);
LABEL
10,40,45,2,1;
VAR
mstate:smallnumber;
p,q:halfword;
k:integer;
BEGIN
q:=Getnode(3);
mem[q+1].int:=w;
mem[q+2].int:=dvioffset+dviptr;
IF o=157 THEN
BEGIN
mem[q].hh.rh:=downptr;
downptr:=q;
END
ELSE
BEGIN
mem[q].hh.rh:=rightptr;
rightptr:=q;
END;
{519}p:=mem[q].hh.rh;
mstate:=0;
WHILE p<>0 DO
BEGIN
IF mem[p+1].int=w THEN
{520}
CASE mstate+mem[p].hh.lh
OF
3,4,15,16:IF mem[p+2].int<dvigone THEN
GOTO 45
ELSE
{521}
BEGIN
k:=mem[
p+2].int-dvioffset;
IF k<0 THEN
k:=k+dvibufsize;
dvibuf[k]:=dvibuf[k]+5;
mem[p].hh.lh:=1;
GOTO 40;
END;
5,9,11:IF mem[p+2].int<dvigone THEN
GOTO 45
ELSE
{522}
BEGIN
k:=mem[p+2].
int-dvioffset;
IF k<0 THEN
k:=k+dvibufsize;
dvibuf[k]:=dvibuf[k]+10;
mem[p].hh.lh:=2;
GOTO 40;
END;
1,2,8,13:GOTO 40;
OTHERS:
END
ELSE
CASE mstate+mem[p].hh.lh OF
1:mstate:=6;
2:mstate:=12;
8,13:GOTO 45;
OTHERS:
END;
p:=mem[p].hh.rh;
END;
45:;
{518}mem[q].hh.lh:=3;
IF Abs(w)>=8388608 THEN
BEGIN
BEGIN
dvibuf[dviptr]:=o+3;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
Dvifour(w);
GOTO 10;
END;
IF Abs(w)>=32768 THEN
BEGIN
BEGIN
dvibuf[dviptr]:=o+2;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
IF w<0 THEN
w:=w+16777216;
BEGIN
dvibuf[dviptr]:=w DIV 65536;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
w:=w MOD 65536;
GOTO 2;
END;
IF Abs(w)>=128 THEN
BEGIN
BEGIN
dvibuf[dviptr]:=o+1;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
IF w<0 THEN
w:=w+65536;
GOTO 2;
END;
BEGIN
dvibuf[dviptr]:=o;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
IF w<0 THEN
w:=w+256;
GOTO 1;
2:
BEGIN
dvibuf[dviptr]:=w DIV 256;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
1:
BEGIN
dvibuf[dviptr]:=w MOD 256;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
GOTO 10;
40:{517}
mem[q].hh.lh:=mem[p].hh.lh;
IF mem[q].hh.lh=1 THEN
BEGIN
BEGIN
dvibuf[dviptr]:=o+4;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
WHILE mem[q].hh.rh<>p DO
BEGIN
q:=mem[q].hh.rh;
CASE mem[q].hh.lh OF
3:mem[q].hh.lh:=5;
4:mem[q].hh.lh:=6;
OTHERS:
END;
END;
END
ELSE
BEGIN
BEGIN
dvibuf[dviptr]:=o+9;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
WHILE mem[q].hh.rh<>p DO
BEGIN
q:=mem[q].hh.rh;
CASE mem[q].hh.lh OF
3:mem[q].hh.lh:=4;
5:mem[q].hh.lh:=6;
OTHERS:
END;
END;
END;
10:
END;
{523}
PROCEDURE Prunemovemen(l:integer);
LABEL
30,10;
VAR
p:halfword;
BEGIN
WHILE downptr<>0 DO
BEGIN
IF mem[downptr+2].int<l THEN
GOTO 30;
p:=downptr;
downptr:=mem[p].hh.rh;
Freenode(p,3);
END;
30:
WHILE rightptr<>0 DO
BEGIN
IF mem[rightptr+2].int<l THEN
GOTO 10;
p:=rightptr;
rightptr:=mem[p].hh.rh;
Freenode(p,3);
END;
10:
END;
{526}
PROCEDURE Vlistout;
FORWARD;
{527}{1225}
PROCEDURE Xsendout(p:halfword);
VAR
oldsetting:0..21;
k:poolpointer;
BEGIN
IF curh<>dvih THEN
BEGIN
Movement(curh-dvih,143);
dvih:=curh;
END;
IF curv<>dviv THEN
BEGIN
Movement(curv-dviv,157);
dviv:=curv;
END;
oldsetting:=selector;
selector:=21;
Showtokenlis(mem[mem[p+1].hh.rh].hh.rh,0,300);
selector:=oldsetting;
BEGIN
IF poolptr+1>poolsize THEN
Overflow(129,poolsize);
END;
IF(poolptr-strstart[strptr])>255 THEN
BEGIN
Printnl(998);
poolptr:=strstart[strptr]+255;
Begindiagnos;
Printcurrent;
Enddiagnosti;
END;
BEGIN
dvibuf[dviptr]:=239;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
BEGIN
dvibuf[dviptr]:=(poolptr-strstart[strptr]);
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
FOR k:=strstart[strptr]TO poolptr-1 DO
BEGIN
dvibuf[dviptr]:=strpool[k];
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
poolptr:=strstart[strptr];
END;
{1227}
PROCEDURE Sendout(p:halfword);
VAR
oldsetting:0..21;
oldmode,oldoffset:integer;
j:smallnumber;
q,r:halfword;
BEGIN{1228}
q:=Getavail;
mem[q].hh.lh:=637;
r:=Getavail;
mem[q].hh.rh:=r;
mem[r].hh.lh:=6455;
Begintokenli(q,3);
Begintokenli(mem[p+1].hh.rh,8);
q:=Getavail;
mem[q].hh.lh:=379;
Begintokenli(q,3);
oldmode:=curlist.modefield;
curlist.modefield:=0;
q:=Scantoks(false,true);
curlist.modefield:=oldmode;
Gettoken;
IF curtok<>6455 THEN
Confusion(990);
Endtokenlist;
oldsetting:=selector;
oldoffset:=offset;
j:=mem[p+1].hh.lh;
IF sendopen[j]THEN
selector:=j
ELSE
Printnl(529);
Showtokenlis(mem[curval].hh.rh,0,bufsize-10);
Println;
Flushlist(curval);
selector:=oldsetting;
IF sendopen[j]THEN
offset:=oldoffset;
END;
{1229}
PROCEDURE Outwhat(p:halfword);
VAR
j:smallnumber;
BEGIN
CASE mem[p].hh.b1 OF
0,1,2:{1230}BEGIN
j:=mem[p+1].hh.lh;
IF j<>16 THEN
BEGIN
IF mem[p].hh.b1=1 THEN
Sendout(p)
ELSE
BEGIN
IF
sendopen[j]THEN
Aclose(sendfile[j]);
IF mem[p].hh.b1=2 THEN
sendopen[j]:=false
ELSE
BEGIN
curname:=mem[p+1].
hh.rh;
curarea:=mem[p+2].hh.lh;
curext:=mem[p+2].hh.rh;
IF curext=529 THEN
curext:=535;
WHILE NOT Aopenout(sendfile[j])DO Promptfilena(1001,535);
sendopen[j]:=true;
END;
END;
mem[p+1].hh.lh:=16;
END;
END;
3:Xsendout(p);
OTHERS:Confusion(1000)
END;
END;
PROCEDURE Hlistout;
LABEL
21,13,14,15;
VAR
baseline:scaled;
saveh,savev:scaled;
thisbox:halfword;
gorder:glueord;
gsign:0..2;
p:halfword;
saveloc:integer;
leaderbox:halfword;
leaderwd:scaled;
edge:scaled;
BEGIN
thisbox:=tempptr;
gorder:=mem[thisbox+5].hh.b1;
gsign:=mem[thisbox+5].hh.b0;
p:=mem[thisbox+5].hh.rh;
curs:=curs+1;
IF curs>maxpush THEN
maxpush:=curs;
saveloc:=dvioffset+dviptr;
baseline:=curv;
WHILE p<>0 DO{528}21:
IF(p>12000)THEN
BEGIN
IF curh<>dvih THEN
BEGIN
Movement(curh-dvih,143);
dvih:=curh;
END;
IF curv<>dviv THEN
BEGIN
Movement(curv-dviv,157);
dviv:=curv;
END;
REPEAT
f:=mem[p].hh.b0;
c:=mem[p].hh.b1;
IF f<>dvif THEN
{529}
BEGIN
IF f<=64 THEN
BEGIN
dvibuf[dviptr]:=f+170;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END
ELSE
BEGIN
BEGIN
dvibuf[dviptr]:=235;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
BEGIN
dvibuf[dviptr]:=f-1;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
END;
dvif:=f;
fontused[f]:=true;
END;
IF c<128 THEN
BEGIN
dvibuf[dviptr]:=(c-0);
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END
ELSE
BEGIN
BEGIN
dvibuf[dviptr]:=128;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
BEGIN
dvibuf[dviptr]:=(c-0);
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
END;
curh:=curh+fontinfo[widthbase[f]+fontinfo[charbase[f]+c].qqqq.b0].int;
p:=mem[p].hh.rh;
UNTIL NOT(p>12000);
dvih:=curh;
END
ELSE
IF p<>0 THEN
{530}
BEGIN
CASE mem[p].hh.b0 OF
0,1:{531}IF mem[p+5
].hh.rh=0 THEN
curh:=curh+mem[p+1].int
ELSE
BEGIN
saveh:=dvih;
savev:=dviv;
BEGIN
dvibuf[dviptr]:=141;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
curv:=baseline+mem[p+4].int;
tempptr:=p;
edge:=curh;
IF mem[p].hh.b0=1 THEN
Vlistout
ELSE
Hlistout;
BEGIN
dvibuf[dviptr]:=142;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
dvih:=saveh;
dviv:=savev;
curh:=edge+mem[p+1].int;
curv:=baseline;
END;
2:BEGIN
ruleht:=mem[p+3].int;
ruledp:=mem[p+2].int;
rulewd:=mem[p+1].int;
GOTO 14;
END;
8:{1223}Outwhat(p);;
9:{533}BEGIN
g:=mem[p+1].hh.lh;
rulewd:=mem[g+1].int;
IF gsign<>0 THEN
BEGIN
IF gsign=1 THEN
BEGIN
IF mem[g].hh.b0=gorder THEN
rulewd:=rulewd+Round(mem[thisbox+6].gr*mem[g+2].int);
END
ELSE
BEGIN
IF mem[g].hh.b1=gorder THEN
rulewd:=rulewd-Round(mem[
thisbox+6].gr*mem[g+3].int);
END;
END;
IF mem[p].hh.b1>=100 THEN
{534}
BEGIN
leaderbox:=mem[p+1].hh.rh;
IF mem[leaderbox].hh.b0=2 THEN
BEGIN
ruleht:=mem[leaderbox+3].int;
ruledp:=mem[leaderbox+2].int;
GOTO 14;
END;
leaderwd:=mem[leaderbox+1].int;
IF(leaderwd>0)AND(rulewd>0)THEN
BEGIN
edge:=curh+rulewd;
{535}
IF mem[p].hh.b1=100 THEN
BEGIN
saveh:=curh;
curh:=leaderwd*(curh DIV leaderwd);
IF curh<saveh THEN
curh:=curh+leaderwd;
END
ELSE
BEGIN
lq:=rulewd DIV leaderwd;
lr:=rulewd MOD leaderwd;
IF mem[p].hh.b1=101 THEN
curh:=curh+(lr DIV 2)
ELSE
BEGIN
lx:=(2*lr+lq+1)
DIV(2*lq+2);
leaderwd:=leaderwd+lx;
curh:=curh+((lr-(lq-1)*lx)DIV 2);
END;
END;
WHILE curh+leaderwd<=edge DO{536}
BEGIN
curv:=baseline+mem[leaderbox+4].
int;
IF curv<>dviv THEN
BEGIN
Movement(curv-dviv,157);
dviv:=curv;
END;
savev:=dviv;
IF curh<>dvih THEN
BEGIN
Movement(curh-dvih,143);
dvih:=curh;
END;
saveh:=dvih;
BEGIN
dvibuf[dviptr]:=141;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
tempptr:=leaderbox;
IF mem[leaderbox].hh.b0=1 THEN
Vlistout
ELSE
Hlistout;
BEGIN
dvibuf[dviptr]:=142;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
dviv:=savev;
dvih:=saveh;
curv:=savev;
curh:=saveh+leaderwd;
END;
curh:=edge;
GOTO 15;
END;
END;
GOTO 13;
END;
10,11:curh:=curh+mem[p+1].int;
6:{558}BEGIN
mem[12012]:=mem[p+1];
mem[12012].hh.rh:=mem[p].hh.rh;
p:=12012;
GOTO 21;
END;
OTHERS:
END;
GOTO 15;
14:{532}
IF(ruleht=-1073741824)THEN
ruleht:=mem[thisbox+3].int;
IF(ruledp=-1073741824)THEN
ruledp:=mem[thisbox+2].int;
ruleht:=ruleht+ruledp;
IF(ruleht>0)AND(rulewd>0)THEN
BEGIN
IF curh<>dvih THEN
BEGIN
Movement(
curh-dvih,143);
dvih:=curh;
END;
curv:=baseline+ruledp;
IF curv<>dviv THEN
BEGIN
Movement(curv-dviv,157);
dviv:=curv;
END;
BEGIN
dvibuf[dviptr]:=132;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
Dvifour(ruleht);
Dvifour(rulewd);
curv:=baseline;
dvih:=dvih+rulewd;
END;
13:
curh:=curh+rulewd;
15:
p:=mem[p].hh.rh;
END;
Prunemovemen(saveloc);
curs:=curs-1;
END;
{537}PROCEDURE Vlistout;
LABEL
13,14,15;
VAR
leftedge:scaled;
saveh,savev:scaled;
thisbox:halfword;
gorder:glueord;
gsign:0..2;
p:halfword;
saveloc:integer;
leaderbox:halfword;
leaderht:scaled;
edge:scaled;
BEGIN
thisbox:=tempptr;
gorder:=mem[thisbox+5].hh.b1;
gsign:=mem[thisbox+5].hh.b0;
p:=mem[thisbox+5].hh.rh;
curs:=curs+1;
IF curs>maxpush THEN
maxpush:=curs;
saveloc:=dvioffset+dviptr;
leftedge:=curh;
curv:=curv-mem[thisbox+3].int;
WHILE p<>0 DO{538}
BEGIN
IF(p>12000)THEN
Confusion(569)
ELSE
{539}
BEGIN
CASE mem[p].hh.b0 OF
0,1:{540}IF mem[p+5].hh.rh=0 THEN
curv:=curv+mem[p
+3].int+mem[p+2].int
ELSE
BEGIN
curv:=curv+mem[p+3].int;
IF curv<>dviv THEN
BEGIN
Movement(curv-dviv,157);
dviv:=curv;
END;
saveh:=dvih;
savev:=dviv;
BEGIN
dvibuf[dviptr]:=141;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
curh:=leftedge+mem[p+4].int;
tempptr:=p;
IF mem[p].hh.b0=1 THEN
Vlistout
ELSE
Hlistout;
BEGIN
dvibuf[dviptr]:=142;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
dvih:=saveh;
dviv:=savev;
curv:=savev+mem[p+2].int;
curh:=leftedge;
END;
2:BEGIN
ruleht:=mem[p+3].int;
ruledp:=mem[p+2].int;
rulewd:=mem[p+1].int;
GOTO 14;
END;
8:{1222}Outwhat(p);;
9:{542}BEGIN
g:=mem[p+1].hh.lh;
ruleht:=mem[g+1].int;
IF gsign<>0 THEN
BEGIN
IF gsign=1 THEN
BEGIN
IF mem[g].hh.b0=gorder THEN
ruleht:=ruleht+Round(mem[thisbox+6].gr*mem[g+2].int);
END
ELSE
BEGIN
IF mem[g].hh.b1=gorder THEN
ruleht:=ruleht-Round(mem[
thisbox+6].gr*mem[g+3].int);
END;
END;
IF mem[p].hh.b1>=100 THEN
{543}
BEGIN
leaderbox:=mem[p+1].hh.rh;
IF mem[leaderbox].hh.b0=2 THEN
BEGIN
rulewd:=mem[leaderbox+1].int;
ruledp:=0;
GOTO 14;
END;
leaderht:=mem[leaderbox+3].int+mem[leaderbox+2].int;
IF(leaderht>0)AND(ruleht>0)THEN
BEGIN
edge:=curv+ruleht;
{544}
IF mem[p].hh.b1=100 THEN
BEGIN
savev:=curv;
curv:=leaderht*(curv DIV leaderht);
IF curv<savev THEN
curv:=curv+leaderht;
END
ELSE
BEGIN
lq:=ruleht DIV leaderht;
lr:=ruleht MOD leaderht;
IF mem[p].hh.b1=101 THEN
curv:=curv+(lr DIV 2)
ELSE
BEGIN
lx:=(2*lr+lq+1)
DIV(2*lq+2);
leaderht:=leaderht+lx;
curv:=curv+((lr-(lq-1)*lx)DIV 2);
END;
END;
WHILE curv+leaderht<=edge DO{545}
BEGIN
curh:=leftedge+mem[leaderbox+4].
int;
IF curh<>dvih THEN
BEGIN
Movement(curh-dvih,143);
dvih:=curh;
END;
saveh:=dvih;
curv:=curv+mem[leaderbox+3].int;
IF curv<>dviv THEN
BEGIN
Movement(curv-dviv,157);
dviv:=curv;
END;
savev:=dviv;
BEGIN
dvibuf[dviptr]:=141;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
tempptr:=leaderbox;
IF mem[leaderbox].hh.b0=1 THEN
Vlistout
ELSE
Hlistout;
BEGIN
dvibuf[dviptr]:=142;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
dviv:=savev;
dvih:=saveh;
curh:=saveh;
curv:=savev-mem[leaderbox+3].int+leaderht;
END;
curv:=edge;
GOTO 15;
END;
END;
GOTO 13;
END;
10:curv:=curv+mem[p+1].int;
OTHERS:
END;
GOTO 15;
14:{541}
IF(rulewd=-1073741824)THEN
rulewd:=mem[thisbox+1].int;
ruleht:=ruleht+ruledp;
curv:=curv+ruleht;
IF(ruleht>0)AND(rulewd>0)THEN
BEGIN
IF curh<>dvih THEN
BEGIN
Movement(
curh-dvih,143);
dvih:=curh;
END;
IF curv<>dviv THEN
BEGIN
Movement(curv-dviv,157);
dviv:=curv;
END;
BEGIN
dvibuf[dviptr]:=137;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
Dvifour(ruleht);
Dvifour(rulewd);
END;
GOTO 15;
13:
curv:=curv+ruleht;
END;
15:
p:=mem[p].hh.rh;
END;
Prunemovemen(saveloc);
curs:=curs-1;
END;
{546}
PROCEDURE Shipout(p:halfword);
VAR
pageloc:integer;
k:0..9;
BEGIN
IF eqtb[3615].int=0 THEN
BEGIN
IF offset>maxprintline-9 THEN
Println
ELSE
Printchar(32);
Printchar(91);
Printint(eqtb[3620].int);
Break(termout);
END
ELSE
BEGIN
Printnl(570);
FOR k:=0 TO 9 DO
BEGIN
Printint(eqtb[3620+k].int);
IF k<9 THEN
Printchar(46);
END;
Printchar(93);
Println;
Begindiagnos;
Showbox(p);
Enddiagnosti;
END;
{548}
IF mem[p+3].int+mem[p+2].int>maxv THEN
maxv:=mem[p+3].int+mem[p+2].
int;
IF mem[p+1].int>maxh THEN
maxh:=mem[p+1].int;
{525}dvih:=0;
dviv:=0;
curh:=0;
dvif:=0;
curs:=-1;
IF outputfilena=0 THEN
BEGIN
Packjobname(539);
WHILE NOT Bopenout(dvifile)DO Promptfilena(540,539);
outputfilena:=Bmakenamestr(dvifile);
END;
;
pageloc:=dvioffset+dviptr;
BEGIN
dvibuf[dviptr]:=139;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
FOR k:=0 TO 9 DO Dvifour(eqtb[3620+k].int);
Dvifour(lastbop);
lastbop:=pageloc;
curv:=mem[p+3].int;
tempptr:=p;
IF mem[p].hh.b0=1 THEN
Vlistout
ELSE
Hlistout;
BEGIN
dvibuf[dviptr]:=140;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
Dviswap;
END;
totalpages:=totalpages+1;
IF eqtb[3615].int=0 THEN
Printchar(93);
Break(termout);
{547}{IF EQTB[3614].INT THEN BEGIN PRINTNL(571);
PRINTINT(VARUSED);
PRINTCHAR(44);
PRINTINT(DYNUSED);
PRINTCHAR(59);
END;
}Flushnodelis(p);
{IF EQTB[3614].INT THEN BEGIN PRINT(572);
PRINTINT(VARUSED);
PRINTCHAR(44);
PRINTINT(DYNUSED);
PRINT(573);
PRINTINT(MAXVARUSED);
PRINTCHAR(44);
PRINTINT(MEMEND-12000);
PRINTLN;
END;};
END;
{553}
PROCEDURE Scanspec;
LABEL
40;
BEGIN
IF Scankeyword(576)THEN
savestack[saveptr+0].int:=0
ELSE
IF
Scankeyword(577)THEN
savestack[saveptr+0].int:=1
ELSE
BEGIN
savestack[
saveptr+0].int:=1;
savestack[saveptr+1].int:=0;
GOTO 40;
END;
Scandimen(false,false,false);
savestack[saveptr+1].int:=curval;
40:
saveptr:=saveptr+2;
Scanleftbrac;
END;
{555}
FUNCTION Hpack(p:halfword;
w:scaled;
m:smallnumber):halfword;
LABEL
21,50,10;
VAR
r:halfword;
q:halfword;
h,d,x:scaled;
s:scaled;
g:halfword;
o:glueord;
f:internalfont;
i:fourquarters;
hd:quarterword;
t:halfword;
b:integer;
BEGIN
r:=Getnode(7);
mem[r].hh.b0:=0;
mem[r].hh.b1:=0;
mem[r+4].int:=0;
q:=r+5;
mem[q].hh.rh:=p;
t:=12006;
h:=0;
{556}d:=0;
x:=0;
FOR o:=0 TO 3 DO
BEGIN
totalstretch[o]:=0;
totalshrink[o]:=0;
END;
WHILE p<>0 DO{557}
BEGIN
21:
WHILE(p>12000)DO{560}
BEGIN
f:=mem[p].hh.b0;
i:=fontinfo[charbase[f]+mem[p].hh.b1].qqqq;
hd:=(i.b1-0);
x:=x+fontinfo[widthbase[f]+i.b0].int;
s:=fontinfo[heightbase[f]+hd DIV 16].int;
IF s>h THEN
h:=s;
s:=fontinfo[depthbase[f]+hd MOD 16].int;
IF s>d THEN
d:=s;
p:=mem[p].hh.rh;
END;
IF p<>0 THEN
BEGIN
CASE mem[p].hh.b0 OF
0,1,2,13:{559}BEGIN
x:=x+mem[p+1
].int;
IF mem[p].hh.b0>=2 THEN
s:=0
ELSE
s:=mem[p+4].int;
IF mem[p+3].int-s>h THEN
h:=mem[p+3].int-s;
IF mem[p+2].int+s>d THEN
d:=mem[p+2].int+s;
END;
3,4,5:{561}BEGIN
WHILE mem[q].hh.rh<>p DO q:=mem[q].hh.rh;
IF mem[p].hh.b0=5 THEN
BEGIN
mem[t].hh.rh:=mem[p+1].int;
WHILE mem[t].hh.rh<>0 DO t:=mem[t].hh.rh;
p:=mem[p].hh.rh;
Freenode(mem[q].hh.rh,2);
END
ELSE
BEGIN
mem[t].hh.rh:=p;
t:=p;
p:=mem[p].hh.rh;
END;
mem[q].hh.rh:=p;
END;
8:{1217};
9:{562}BEGIN
g:=mem[p+1].hh.lh;
x:=x+mem[g+1].int;
o:=mem[g].hh.b0;
totalstretch[o]:=totalstretch[o]+mem[g+2].int;
o:=mem[g].hh.b1;
totalshrink[o]:=totalshrink[o]+mem[g+3].int;
END;
10,11:x:=x+mem[p+1].int;
6:{558}BEGIN
mem[12012]:=mem[p+1];
mem[12012].hh.rh:=mem[p].hh.rh;
p:=12012;
GOTO 21;
END;
OTHERS:
END;
p:=mem[p].hh.rh;
END;
END;
mem[t].hh.rh:=0;
mem[r+3].int:=h;
mem[r+2].int:=d;
{563}
IF m=1 THEN
w:=x+w;
mem[r+1].int:=w;
x:=w-x;
IF x=0 THEN
BEGIN
mem[r+5].hh.b0:=0;
mem[r+5].hh.b1:=0;
mem[r+6].gr:=0.0;
GOTO 10;
END
ELSE
IF x>0 THEN
{564}
BEGIN{565}
IF totalstretch[3]<>0 THEN
o:=3
ELSE
IF totalstretch[2]<>0 THEN
o:=2
ELSE
IF totalstretch[1]<>0 THEN
o:=1
ELSE
o:=0;
mem[r+5].hh.b1:=o;
mem[r+5].hh.b0:=1;
IF totalstretch[o]=0 THEN
mem[r+6].gr:=0.0
ELSE
mem[r+6].gr:=x/
totalstretch[o];
IF(eqtb[3609].int<10000)AND(o=0)AND(mem[r+5].hh.rh<>0)THEN
{566}
BEGIN
b:=
Badness(x,totalstretch[0]);
IF b>eqtb[3609].int THEN
BEGIN
IF b>100 THEN
Printnl(578)
ELSE
Printnl(
579);
Print(580);
Printint(b);
GOTO 50;
END;
END;
GOTO 10;
END
ELSE
{570}
BEGIN{571}
IF totalshrink[3]<>0 THEN
o:=3
ELSE
IF
totalshrink[2]<>0 THEN
o:=2
ELSE
IF totalshrink[1]<>0 THEN
o:=1
ELSE
o:=
0;
mem[r+5].hh.b1:=o;
mem[r+5].hh.b0:=2;
IF totalshrink[o]=0 THEN
mem[r+6].gr:=0.0
ELSE
mem[r+6].gr:=-x/
totalshrink[o];
IF(totalshrink[o]<-x)AND(o=0)AND(mem[r+5].hh.rh<>0)THEN
BEGIN
mem[r+6].
gr:=1.0;
{572}
IF-x-totalshrink[0]>eqtb[4012].int THEN
BEGIN
IF eqtb[4020].int>0
THEN
BEGIN
WHILE mem[q].hh.rh<>0 DO q:=mem[q].hh.rh;
mem[q].hh.rh:=Newrule;
mem[mem[q].hh.rh+1].int:=eqtb[4020].int;
END;
Printnl(585);
Printscaled(-x-totalshrink[0]);
Print(586);
GOTO 50;
END;
END
ELSE
IF(eqtb[3609].int<100)AND(o=0)AND(mem[r+5].hh.rh<>0)THEN
{573}
BEGIN
b:=Badness(x,totalshrink[0]);
IF b>eqtb[3609].int THEN
BEGIN
Printnl(587);
Printint(b);
GOTO 50;
END;
END;
GOTO 10;
END;
50:{569}
IF outputactive THEN
Print(581)
ELSE
BEGIN
IF parbeginline<>0
THEN
BEGIN
Print(582);
Printint(parbeginline);
Print(583);
END
ELSE
Print(584);
Printint(line);
Printchar(58);
END;
Println;
fontinshortd:=0;
Shortdisplay(mem[r+5].hh.rh);
Println;
Begindiagnos;
Showbox(r);
Enddiagnosti;
10:
Hpack:=r;
END;
{574}
FUNCTION Vpackage(p:halfword;
h:scaled;
m:smallnumber;
l:scaled):halfword;
LABEL
50,10;
VAR
r:halfword;
w,d,x:scaled;
s:scaled;
g:halfword;
o:glueord;
f:internalfont;
i:fourquarters;
hd:quarterword;
b:integer;
BEGIN
r:=Getnode(7);
mem[r].hh.b0:=1;
mem[r].hh.b1:=0;
mem[r+4].int:=0;
mem[r+5].hh.rh:=p;
w:=0;
{556}d:=0;
x:=0;
FOR o:=0 TO 3 DO
BEGIN
totalstretch[o]:=0;
totalshrink[o]:=0;
END;
WHILE p<>0 DO{575}
BEGIN
IF(p>12000)THEN
Confusion(588)
ELSE
CASE mem[p].
hh.b0 OF
0,1,2,13:{576}BEGIN
x:=x+d+mem[p+3].int;
d:=mem[p+2].int;
IF mem[p].hh.b0>=2 THEN
s:=0
ELSE
s:=mem[p+4].int;
IF mem[p+1].int+s>w THEN
w:=mem[p+1].int+s;
END;
8:{1216};
9:BEGIN
x:=x+d;
d:=0;
{562}
BEGIN
g:=mem[p+1].hh.lh;
x:=x+mem[g+1].int;
o:=mem[g].hh.b0;
totalstretch[o]:=totalstretch[o]+mem[g+2].int;
o:=mem[g].hh.b1;
totalshrink[o]:=totalshrink[o]+mem[g+3].int;
END;
END;
10:BEGIN
x:=x+d+mem[p+1].int;
d:=0;
END;
OTHERS:
END;
p:=mem[p].hh.rh;
END;
mem[r+1].int:=w;
IF d>l THEN
BEGIN
x:=x+d-l;
mem[r+2].int:=l;
END
ELSE
mem[r+2].int:=d;
{577}
IF m=1 THEN
h:=x+h;
mem[r+3].int:=h;
x:=h-x;
IF x=0 THEN
BEGIN
mem[r+5].hh.b0:=0;
mem[r+5].hh.b1:=0;
mem[r+6].gr:=0.0;
GOTO 10;
END
ELSE
IF x>0 THEN
{578}
BEGIN{565}
IF totalstretch[3]<>0 THEN
o:=3
ELSE
IF totalstretch[2]<>0 THEN
o:=2
ELSE
IF totalstretch[1]<>0 THEN
o:=1
ELSE
o:=0;
mem[r+5].hh.b1:=o;
mem[r+5].hh.b0:=1;
IF totalstretch[o]=0 THEN
mem[r+6].gr:=0.0
ELSE
mem[r+6].gr:=x/
totalstretch[o];
IF(eqtb[3610].int<10000)AND(o=0)AND(mem[r+5].hh.rh<>0)THEN
{579}
BEGIN
b:=
Badness(x,totalstretch[0]);
IF b>eqtb[3610].int THEN
BEGIN
IF b>100 THEN
Printnl(578)
ELSE
Printnl(
579);
Print(580);
Printint(b);
GOTO 50;
END;
END;
GOTO 10;
END
ELSE
{581}
BEGIN{571}
IF totalshrink[3]<>0 THEN
o:=3
ELSE
IF
totalshrink[2]<>0 THEN
o:=2
ELSE
IF totalshrink[1]<>0 THEN
o:=1
ELSE
o:=
0;
mem[r+5].hh.b1:=o;
mem[r+5].hh.b0:=2;
IF totalshrink[o]=0 THEN
mem[r+6].gr:=0.0
ELSE
mem[r+6].gr:=-x/
totalshrink[o];
IF(totalshrink[o]<-x)AND(o=0)AND(mem[r+5].hh.rh<>0)THEN
BEGIN
mem[r+6].
gr:=1.0;
{582}
IF-x-totalshrink[0]>eqtb[4013].int THEN
BEGIN
Printnl(589);
Printscaled(-x-totalshrink[0]);
Print(590);
GOTO 50;
END;
END
ELSE
IF(eqtb[3610].int<100)AND(o=0)AND(mem[r+5].hh.rh<>0)THEN
{583}
BEGIN
b:=Badness(x,totalshrink[0]);
IF b>eqtb[3610].int THEN
BEGIN
Printnl(591);
Printint(b);
GOTO 50;
END;
END;
GOTO 10;
END;
50:{580}
IF outputactive THEN
Print(581)
ELSE
BEGIN
Print(584);
Printint(line);
Printchar(58);
Println;
Begindiagnos;
Showbox(r);
Enddiagnosti;
END;
10:
Vpackage:=r;
END;
{584}
PROCEDURE Appendtovlis(b:halfword);
VAR
d:scaled;
p:halfword;
BEGIN
IF curlist.auxfield<>-65536000 THEN
BEGIN
d:=mem[eqtb[2362].hh.rh
+1].int-curlist.auxfield-mem[b+3].int;
IF d<eqtb[4007].int THEN
p:=Newparamglue(0)
ELSE
BEGIN
p:=Newspec(eqtb[
2362].hh.rh);
mem[p+1].int:=d;
p:=Newglue(p);
mem[p].hh.b1:=2;
END;
mem[curlist.tailfield].hh.rh:=p;
curlist.tailfield:=p;
END;
mem[curlist.tailfield].hh.rh:=b;
curlist.tailfield:=b;
curlist.auxfield:=mem[b+2].int;
END;
{591}
FUNCTION Newnoad:halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(4);
mem[p].hh.b0:=22;
mem[p].hh.b1:=0;
mem[p+1].hh:=emptyfield;
mem[p+3].hh:=emptyfield;
mem[p+2].hh:=emptyfield;
Newnoad:=p;
END;
{593}
FUNCTION Newstyle(s:smallnumber):halfword;
VAR
p:halfword;
BEGIN
p:=Getnode(2);
mem[p].hh.b0:=14;
mem[p].hh.b1:=s;
mem[p+1].int:=0;
Newstyle:=p;
END;
{597}PROCEDURE Showinfo;
BEGIN
Shownodelist(mem[tempptr].hh.lh);
END;
{606}
FUNCTION Fractionrule(t:scaled):halfword;
VAR
p:halfword;
BEGIN
p:=Newrule;
mem[p+3].int:=t;
mem[p+2].int:=0;
Fractionrule:=p;
END;
{607}
FUNCTION Overbar(b:halfword;
k,t:scaled):halfword;
VAR
p,q:halfword;
BEGIN
p:=Newkern(k);
mem[p].hh.rh:=b;
q:=Fractionrule(t);
mem[q].hh.rh:=p;
p:=Newkern(t);
mem[p].hh.rh:=q;
Overbar:=Vpackage(p,0,1,134217727);
END;
{608}
FUNCTION Vardelimiter(d:halfword;
s:smallnumber;
v:scaled):halfword;
LABEL
40,30,22;
VAR
b:halfword;
f,g:internalfont;
c,x,y:quarterword;
m,n:integer;
u:scaled;
w:scaled;
q:fourquarters;
hd:eightbits;
r:fourquarters;
p:halfword;
z:smallnumber;
largeattempt:boolean;
{612}
PROCEDURE Stackintobox;
BEGIN
p:=Getavail;
mem[p].hh.b0:=f;
mem[p].hh.b1:=c;
p:=Hpack(p,0,1);
mem[p].hh.rh:=mem[b+5].hh.rh;
mem[b+5].hh.rh:=p;
mem[b+3].int:=mem[p+3].int;
END;
{613}
PROCEDURE Updatew;
BEGIN
q:=fontinfo[charbase[f]+c].qqqq;
hd:=(q.b1-0);
w:=w+fontinfo[heightbase[f]+hd DIV 16].int;
w:=w+fontinfo[depthbase[f]+hd MOD 16].int;
END;
BEGIN
f:=0;
w:=0;
largeattempt:=false;
z:=mem[d].qqqq.b0;
x:=mem[d].qqqq.b1;
WHILE true DO
BEGIN{609}
IF(z<>0)OR(x<>0)THEN
BEGIN
z:=z+s+16;
REPEAT
z:=z-16;
g:=eqtb[2894+z].hh.rh;
IF g<>0 THEN
{610}
BEGIN
y:=x;
22:
IF((y-0)>=fontbc[g])AND((y-0)<=fontec[g])THEN
BEGIN
q:=fontinfo[
charbase[g]+y].qqqq;
IF(q.b0>0)THEN
BEGIN
IF((q.b2-0)MOD 4)=3 THEN
GOTO 40;
hd:=(q.b1-0);
u:=fontinfo[heightbase[g]+hd DIV 16].int+fontinfo[depthbase[g]+hd MOD 16
].int;
IF u>w THEN
BEGIN
f:=g;
c:=y;
w:=u;
IF u>=v THEN
GOTO 40;
END;
IF((q.b2-0)MOD 4)=2 THEN
BEGIN
y:=q.b3;
GOTO 22;
END;
END;
END;
END;
UNTIL z<16;
END;
IF largeattempt THEN
GOTO 40;
largeattempt:=true;
z:=mem[d].qqqq.b2;
x:=mem[d].qqqq.b3;
END;
40:
IF f<>0 THEN
{611}
IF((q.b2-0)MOD 4)=3 THEN
{614}
BEGIN
b:=Newnullbox;
mem[b].hh.b0:=1;
r:=fontinfo[extenbase[f]+q.b3].qqqq;
{615}w:=0;
c:=r.b3;
Updatew;
u:=w;
w:=0;
mem[b+1].int:=fontinfo[widthbase[f]+q.b0].int;
c:=r.b2;
IF c<>0 THEN
Updatew;
c:=r.b1;
IF c<>0 THEN
Updatew;
c:=r.b0;
IF c<>0 THEN
Updatew;
n:=0;
IF u>0 THEN
WHILE w<v DO
BEGIN
w:=w+u;
n:=n+1;
IF r.b1<>0 THEN
w:=w+u;
END;
c:=r.b2;
IF c<>0 THEN
Stackintobox;
c:=r.b3;
FOR m:=1 TO n DO Stackintobox;
c:=r.b1;
IF c<>0 THEN
BEGIN
Stackintobox;
c:=r.b3;
FOR m:=1 TO n DO Stackintobox;
END;
c:=r.b0;
IF c<>0 THEN
Stackintobox;
mem[b+2].int:=w-mem[b+3].int;
END
ELSE
BEGIN
p:=Getavail;
mem[p].hh.b0:=f;
mem[p].hh.b1:=c;
mem[b+5].hh.rh:=p;
b:=Hpack(p,0,1);
END
ELSE
BEGIN
b:=Newnullbox;
mem[b+1].int:=eqtb[4015].int;
END;
mem[b+4].int:=Half(mem[b+3].int-mem[b+2].int)-fontinfo[22+parambase[eqtb
[2896+s].hh.rh]].int;
Vardelimiter:=b;
END;
{616}
FUNCTION Rebox(b:halfword;
w:scaled):halfword;
VAR
p:halfword;
BEGIN
IF(mem[b+1].int<>w)AND(mem[b+5].hh.rh<>0)THEN
BEGIN
p:=mem[b+5].hh
.rh;
Freenode(b,7);
b:=Newglue(12);
mem[b].hh.rh:=p;
WHILE mem[p].hh.rh<>0 DO p:=mem[p].hh.rh;
mem[p].hh.rh:=Newglue(12);
Rebox:=Hpack(b,w,0);
END
ELSE
BEGIN
mem[b+1].int:=w;
Rebox:=b;
END;
END;
{617}
FUNCTION Mathglue(g:halfword;
m:scaled):halfword;
VAR
p:halfword;
n:integer;
f:scaled;
BEGIN
n:=Xovern(m,65536);
f:=remainder;
p:=Getnode(4);
mem[p+1].int:=Nxplusy(n,mem[g+1].int,f);
mem[p].hh.b0:=mem[g].hh.b0;
IF mem[p].hh.b0=0 THEN
mem[p+2].int:=Nxplusy(n,mem[g+2].int,f)
ELSE
mem[p
+2].int:=mem[g+2].int;
mem[p].hh.b1:=mem[g].hh.b1;
IF mem[p].hh.b1=0 THEN
mem[p+3].int:=Nxplusy(n,mem[g+3].int,f)
ELSE
mem[p
+3].int:=mem[g+3].int;
Mathglue:=p;
END;
{618}
PROCEDURE Mathkern(p:halfword;
m:scaled);
VAR
n:integer;
f:scaled;
BEGIN
IF mem[p].hh.b1=98 THEN
BEGIN
n:=Xovern(m,65536);
f:=remainder;
mem[p+1].int:=Nxplusy(n,mem[p+1].int,f);
mem[p].hh.b1:=0;
END;
END;
{620}
FUNCTION Mlisttohlist(mlist:halfword;
style:smallnumber;
penalties:boolean):halfword;
LABEL
21,82,80,81,83,30,31;
VAR
q:halfword;
r:halfword;
rtype:smallnumber;
t:smallnumber;
p,v,x,y,z:halfword;
pen:integer;
s:smallnumber;
maxh,maxd:scaled;
curstyle,cursize:smallnumber;
curmu:scaled;
f:internalfont;
c:quarterword;
i:fourquarters;
a:0..fontmemsize;
delta,delta1,delta2,clr,shiftup,shiftdown:scaled;
{626}
PROCEDURE Fetch(a:halfword);
BEGIN
c:=mem[a].hh.b1;
f:=eqtb[2894+mem[a].hh.b0+cursize].hh.rh;
IF f=0 THEN
{627}
BEGIN
Printnl(618);
Printsize(cursize);
Print(32);
Printint(mem[a].hh.b0);
Print(619);
BEGIN
helpptr:=3;
helpline[2]:=620;
helpline[1]:=621;
helpline[0]:=622;
END;
Error;
i:=nullcharacte;
mem[a].hh.rh:=0;
END
ELSE
BEGIN
IF((c-0)>=fontbc[f])AND((c-0)<=fontec[f])THEN
i:=fontinfo
[charbase[f]+c].qqqq
ELSE
i:=nullcharacte;
IF NOT((i.b0>0))THEN
BEGIN
Charwarning(f,c);
mem[a].hh.rh:=0;
END;
END;
END;
{628}FUNCTION Cleanbox(p:halfword;
s:smallnumber):halfword;
LABEL
10;
VAR
a:halfword;
h:halfword;
BEGIN
CASE mem[p].hh.rh OF
1:BEGIN
a:=Newnoad;
mem[a+1]:=mem[p];
mem[a].hh.b0:=15;
h:=Mlisttohlist(a,s,false);
END;
2:BEGIN
h:=mem[p].hh.lh;
IF mem[h+4].int=0 THEN
BEGIN
Cleanbox:=h;
GOTO 10;
END;
END;
3:h:=Mlisttohlist(mem[p].hh.lh,s,false);
OTHERS:h:=0
END;
Cleanbox:=Hpack(h,0,1);
10:
END;
BEGIN
q:=mlist;
r:=0;
rtype:=16;
maxh:=0;
maxd:=0;
curstyle:=style;
{605}
BEGIN
IF curstyle<4 THEN
cursize:=0
ELSE
cursize:=16*((curstyle-2) DIV 2);
curmu:=Xovern(fontinfo[6+parambase[eqtb[2896+curstyle].hh.rh]].int,18);
END;
WHILE q<>0 DO{621}
BEGIN{622}
21:
delta:=0;
CASE mem[q].hh.b0 OF
17:CASE rtype OF
17,16,18,19,21,29:BEGIN
mem[q].hh.
b0:=15;
GOTO 21;
END;
OTHERS:
END;
18,20,21,30:BEGIN
IF rtype=17 THEN mem[r].hh.b0:=15;
IF mem[q].hh.b0=30 THEN GOTO 80;
END;
{625}29:GOTO 80;
24:{632}BEGIN{633}
x:=Cleanbox(q+2,curstyle+2-2*(curstyle DIV 6));
z:=Cleanbox(q+3,2*(curstyle DIV 2)+3-2*(curstyle DIV 6));
IF mem[x+1].int<mem[z+1].int THEN x:=Rebox(x,mem[z+1].int)
ELSE z:=Rebox(z,mem[x+1].int);
IF curstyle<2 THEN
BEGIN
shiftup:=fontinfo[8+parambase[eqtb[2896+cursize].hh.rh]].int;
shiftdown:=fontinfo[11+parambase[eqtb[2896+cursize].hh.rh]].int;
END
ELSE
BEGIN
shiftdown:=fontinfo[12+parambase[eqtb[2896+cursize].hh.rh]].int;
IF mem[q+1].int<>0 THEN
shiftup:=fontinfo[9+parambase[eqtb[2896+cursize]
.hh.rh]].int
ELSE
shiftup:=fontinfo[10+parambase[eqtb[2896+cursize].hh.rh]].int;
END;
IF mem[q+1].int=0 THEN
{634}
BEGIN
IF curstyle<2 THEN
clr:=7*fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].int
ELSE
clr:=3*fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].int;
delta:=Half(clr-((shiftup-mem[x+2].int)-(mem[z+3].int-shiftdown)));
IF delta>0 THEN
BEGIN
shiftup:=shiftup+delta;
shiftdown:=shiftdown-delta;
END;
END
ELSE
{635}
BEGIN
IF mem[q+1].int=1073741824 THEN
mem[q+1].int:=fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].int;
IF curstyle<2 THEN clr:=3*mem[q+1].int
ELSE clr:=mem[q+1].int;
delta:=Half(mem[q+1].int);
delta1:=clr-((shiftup-mem[x+2].int)
-(fontinfo[22+parambase[eqtb[2896+cursize].hh.rh]].int+delta));
delta2:=clr-((fontinfo[22+parambase[eqtb[2896+cursize].hh.rh]].int-delta)
-(mem[z+3].int-shiftdown));
IF delta1>0 THEN shiftup:=shiftup+delta1;
IF delta2>0 THEN shiftdown:=shiftdown+delta2;
END;
{636}v:=Newnullbox;
mem[v].hh.b0:=1;
mem[v+3].int:=shiftup+mem[x+3].int;
mem[v+2].int:=mem[z+2].int+shiftdown;
mem[v+1].int:=mem[x+1].int;
IF mem[q+1].int=0 THEN
BEGIN
p:=Newkern((shiftup-mem[x+2].int)-(mem[z+3].int-shiftdown));
mem[p].hh.rh:=z;
END
ELSE
BEGIN
y:=Fractionrule(mem[q+1].int);
p:=Newkern((fontinfo[22+parambase[eqtb[2896+cursize].hh.rh]].int-delta)-
(mem[z+3].int-shiftdown));
mem[y].hh.rh:=p;
p:=Newkern((shiftup-mem[x+2].int)-(fontinfo[22+parambase[eqtb[2896+
cursize].hh.rh]].int+delta));
mem[p].hh.rh:=y;
END;
mem[x].hh.rh:=p;
mem[v+5].hh.rh:=x;
{637}
IF curstyle<2 THEN
delta:=fontinfo[20+parambase[eqtb[2896+cursize].hh.rh]].int
ELSE
delta:=fontinfo[21+parambase[eqtb[2896+cursize].hh.rh]].int;
x:=Vardelimiter(q+4,cursize,delta);
mem[x].hh.rh:=v;
z:=Vardelimiter(q+5,cursize,delta);
mem[v].hh.rh:=z;
mem[p+1].int:=Hpack(x,0,1);
GOTO 82;
END;
16:{629}BEGIN
IF mem[q+1].hh.rh=1 THEN
BEGIN
Fetch(q+1);
IF(curstyle<2)AND(((i.b2-0)MOD 4)=2)THEN
BEGIN
c:=i.b3;
mem[q+1].hh.b1:=c;
i:=fontinfo[charbase[f]+c].qqqq;
END;
delta:=fontinfo[italicbase[f]+(i.b2-0)DIV 4].int;
x:=Cleanbox(q+1,curstyle);
mem[x+1].int:=mem[x+1].int-delta;
mem[x+4].int:=Half(mem[x+3].int-mem[x+2].int)-fontinfo[22+parambase[eqtb
[2896+s].hh.rh]].int;
mem[q+1].hh.rh:=2;
mem[q+1].hh.lh:=x;
END
ELSE
delta:=0;
IF curstyle<2 THEN
IF((delta=0)AND(mem[q].hh.b1=0))OR((delta<>0)
AND(mem[q].hh.b1=1))THEN
{630}
BEGIN
x:=Cleanbox(q+2,2*(curstyle DIV 4)+4+(curstyle MOD 2));
y:=Cleanbox(q+1,curstyle);
z:=Cleanbox(q+3,2*(curstyle DIV 4)+5);
v:=Newnullbox;
mem[v].hh.b0:=1;
mem[v+1].int:=mem[y+1].int;
IF mem[x+1].int>mem[v+1].int THEN mem[v+1].int:=mem[x+1].int;
IF mem[z+1].int>mem[v+1].int THEN mem[v+1].int:=mem[z+1].int;
x:=Rebox(x,mem[v+1].int);
y:=Rebox(y,mem[v+1].int);
z:=Rebox(z,mem[v+1].int);
mem[x+4].int:=Half(delta);
mem[z+4].int:=-mem[x+4].int;
mem[v+3].int:=mem[y+3].int;
mem[v+2].int:=mem[y+2].int;
{631}
IF mem[q+2].hh.rh=0 THEN
BEGIN
Freenode(x,7);
mem[v+5].hh.rh:=y;
END
ELSE
BEGIN
shiftup:=fontinfo[11+parambase[eqtb[2897+cursize].hh.rh]]
.int-mem[x+2].int;
IF shiftup<fontinfo[9+parambase[eqtb[2897+cursize].hh.rh]].int THEN
shiftup:=fontinfo[9+parambase[eqtb[2897+cursize].hh.rh]].int;
p:=Newkern(shiftup);
mem[p].hh.rh:=y;
mem[x].hh.rh:=p;
p:=Newkern(fontinfo[13+parambase[eqtb[2897+cursize].hh.rh]].int);
mem[p].hh.rh:=x;
mem[v+5].hh.rh:=p;
mem[v+3].int:=mem[v+3].int+fontinfo[13+parambase[eqtb[2897+cursize].hh.
rh]].int+mem[x+3].int+mem[x+2].int+shiftup;
END;
IF mem[q+3].hh.rh=0 THEN
Freenode(z,7)
ELSE
BEGIN
shiftdown:=fontinfo[12+
parambase[eqtb[2897+cursize].hh.rh]].int-mem[z+3].int;
IF shiftdown<fontinfo[10+parambase[eqtb[2897+cursize].hh.rh]].int THEN
shiftdown:=fontinfo[10+parambase[eqtb[2897+cursize].hh.rh]].int;
p:=Newkern(shiftdown);
mem[y].hh.rh:=p;
mem[p].hh.rh:=z;
p:=Newkern(fontinfo[13+parambase[eqtb[2897+cursize].hh.rh]].int);
mem[z].hh.rh:=p;
mem[v+2].int:=mem[v+2].int+fontinfo[13+parambase[eqtb[2897+cursize].hh.
rh]].int+mem[z+3].int+mem[z+2].int+shiftdown;
END;
mem[p+1].int:=v;
GOTO 82;
END;
IF(delta<>0)AND(mem[q+3].hh.rh=0)THEN
mem[x+1].int:=mem[x+1].int+delta;
END;
15:{644}IF(mem[q+3].hh.rh=0)AND(mem[q+2].hh.rh=0)AND(mem[q+1].hh.rh=1)
THEN
BEGIN
p:=mem[q].hh.rh;
IF p<>0 THEN
IF(mem[p].hh.b0>=15)AND(mem[p].hh.b0<=21)THEN
IF mem[p+1].
hh.rh=1 THEN
IF mem[p+1].hh.b0=mem[q+1].hh.b0 THEN
BEGIN
Fetch(q+1);
IF((i.b2-0)MOD 4)=1 THEN
BEGIN
a:=ligkernbase[f]+i.b3;
c:=mem[p+1].hh.b1;
REPEAT
i:=fontinfo[a].qqqq;
{645}
IF i.b1=c THEN
IF i.b2>=128 THEN
BEGIN
p:=Newcharacter(f,mem[q+1].
hh.b1);
mem[p].hh.rh:=Newkern(fontinfo[kernbase[f]+i.b3].int);
mem[p+1].int:=p;
GOTO 82;
END
ELSE
BEGIN
mem[q].hh.rh:=mem[p].hh.rh;
mem[q+1].hh.b1:=i.b3;
mem[q+3]:=mem[p+3];
mem[q+2]:=mem[p+2];
Freenode(p,4);
GOTO 21;
END;
a:=a+1;
UNTIL i.b0>=128;
END;
END;
END;
19,22:;
23:{638}BEGIN
x:=Cleanbox(q+1,2*(curstyle DIV 2)+1);
IF curstyle<2 THEN
clr:=fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].
int+(fontinfo[5+parambase[eqtb[2896+cursize].hh.rh]].int DIV 4)
ELSE
BEGIN
clr:=fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].int;
clr:=clr+(clr DIV 4);
END;
y:=Vardelimiter(q+4,cursize,mem[x+3].int+mem[x+2].int+clr+fontinfo[8+
parambase[eqtb[2897+cursize].hh.rh]].int);
IF mem[y+3].int<=0 THEN
mem[y+3].int:=fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].int;
delta1:=mem[y+2].int-(mem[x+3].int+mem[x+2].int+clr);
IF delta1>0 THEN clr:=clr+Half(delta1);
mem[y+4].int:=-(mem[x+3].int+clr);
mem[y].hh.rh:=Overbar(x,clr,mem[y+3].int);
mem[q+1].hh.lh:=Hpack(y,0,1);
mem[q+1].hh.rh:=2;
END;
26:{639}BEGIN
mem[q+1].hh.lh:=Overbar(Cleanbox(q+1,2*(curstyle DIV 2)+1)
,3*fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].int,fontinfo[8+
parambase[eqtb[2897+cursize].hh.rh]].int);
mem[q+1].hh.rh:=2;
END;
25:{640}BEGIN
x:=Cleanbox(q+1,curstyle);
p:=Newkern(3*fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].int);
mem[x].hh.rh:=p;
mem[p].hh.rh:=Fractionrule(fontinfo[8+parambase
[eqtb[2897+cursize].hh.rh]].int);
v:=Vpackage(x,0,1,134217727);
delta1:=mem[v+3].int+mem[v+2].int+
fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].int;
mem[v+3].int:=mem[x+3].int;
mem[v+2].int:=delta1-mem[v+3].int;
mem[q+1].hh.lh:=v;
mem[q+1].hh.rh:=2;
END;
27:{641}BEGIN
Fetch(q+4);
IF(i.b0>0)THEN
BEGIN
x:=Cleanbox(q+1,2*(curstyle DIV 2)+1);
{642}
WHILE true DO
BEGIN
IF((i.b2-0)MOD 4)<>2 THEN
GOTO 31;
y:=i.b3;
i:=fontinfo[charbase[f]+y].qqqq;
IF fontinfo[widthbase[f]+i.b0].int>mem[x+1].int THEN
GOTO 31;
c:=y;
END;
31:;
delta1:=mem[x+3].int-fontinfo[5+parambase[f]].int;
IF delta1<0 THEN
delta1:=0;
y:=Hpack(Newcharacter(f,c),0,1);
mem[y+4].int:=Half(mem[x+1].int-mem[y+1].int);
mem[y+1].int:=0;
p:=Newglue(12);
mem[p].hh.rh:=x;
mem[y].hh.rh:=p;
mem[q+1].hh.lh:=Vpackage(y,mem[y+3].int+delta1,0,134217727);
mem[q+1].hh.rh:=2;
END;
END;
28:{643}BEGIN
v:=mem[q+1].hh.lh;
IF mem[v].hh.b0<>1 THEN
Confusion(332);
delta1:=mem[v+3].int+mem[v+2].int;
mem[v+3].int:=fontinfo[22+parambase[eqtb[2896+
cursize].hh.rh]].int+Half(delta1);
mem[v+2].int:=mem[v+3].int-mem[v+2].int;
END;
{623}14:BEGIN
curstyle:=mem[q].hh.b1;
{605}
BEGIN
IF curstyle<4 THEN cursize:=0
ELSE cursize:=16*((curstyle-2) DIV 2);
curmu:=Xovern(fontinfo[6+parambase[eqtb[2896+curstyle].hh.rh]].int,18);
END;
GOTO 81;
END;
8,12,7:GOTO 81;
2:BEGIN
IF mem[q+3].int>maxh THEN maxh:=mem[q+3].int;
IF mem[q+2].int>maxd THEN maxd:=mem[q+2].int;
GOTO 81;
END;
9:BEGIN{624}
IF mem[q].hh.b1=98 THEN
BEGIN
x:=mem[q+1].hh.lh;
y:=Mathglue(x,curmu);
Deletegluere(x);
mem[q+1].hh.lh:=y;
END
ELSE
IF(cursize>0)AND(mem[q].hh.b1=99)THEN
BEGIN
p:=mem[q].hh.rh;
IF p<>0 THEN
IF(mem[p].hh.b0=9)OR(mem[p].hh.b0=10)THEN
BEGIN
mem[q].hh.
rh:=mem[p].hh.rh;
mem[p].hh.rh:=0;
Flushnodelis(p);
END;
END;
GOTO 81;
END;
10:BEGIN
Mathkern(q,curmu);
GOTO 81;
END;
OTHERS:Confusion(617)
END;
{646}
CASE mem[q+1].hh.rh OF
1:{647}BEGIN
Fetch(q+1);
IF(i.b0>0)THEN
BEGIN
delta:=fontinfo[italicbase[f]+(i.b2-0)DIV 4].int;
p:=Newcharacter(f,c);
IF(mem[q+3].hh.rh=0)AND(delta<>0)THEN
BEGIN
mem[p].hh.rh:=Newkern(delta);
delta:=0;
END;
END
ELSE
p:=0;
END;
0:p:=0;
2:p:=mem[q+1].hh.lh;
3:p:=Hpack(Mlisttohlist(mem[q+1].hh.lh,curstyle,false),0,1);
OTHERS:Confusion(623)
END;
mem[p+1].int:=p;
IF(mem[q+3].hh.rh=0)AND(mem[q+2].hh.rh=0)THEN
GOTO 82;
{648}
IF(p>12000)THEN
BEGIN
shiftup:=0;
shiftdown:=0;
END
ELSE
BEGIN
z:=Hpack(p,0,1);
IF curstyle<4 THEN t:=16
ELSE t:=32;
shiftup:=mem[z+3].int-fontinfo[18+parambase[eqtb[2896+t].hh.rh]].int;
shiftdown:=mem[z+2].int+fontinfo[19+parambase[eqtb[2896+t].hh.rh]].int;
Freenode(z,7);
END;
IF mem[q+2].hh.rh=0 THEN
{649}
BEGIN
x:=Cleanbox(q+3,2*(curstyle DIV 4)+5);
mem[x+1].int:=mem[x+1].int+eqtb[4016].int;
IF shiftdown<fontinfo[16+parambase[eqtb[2896+cursize].hh.rh]].int THEN
shiftdown:=fontinfo[16+parambase[eqtb[2896+cursize].hh.rh]].int;
clr:=mem[x+3].int-((fontinfo[5+parambase[eqtb[2896+
cursize].hh.rh]].int*4)DIV 5);
IF shiftdown<clr THEN shiftdown:=clr;
mem[x+4].int:=shiftdown;
END
ELSE
BEGIN{650}
BEGIN
x:=Cleanbox(q+2,2*(curstyle DIV 4)+4+(curstyle MOD 2));
mem[x+1].int:=mem[x+1].int+eqtb[4016].int;
IF Odd(curstyle)THEN
clr:=fontinfo[15+parambase[eqtb[2896+cursize].hh.rh]].int
ELSE
IF curstyle<2 THEN
clr:=fontinfo[13+parambase[eqtb[2896+cursize].hh.rh]].int
ELSE
clr:=fontinfo[14+parambase[eqtb[2896+cursize].hh.rh]].int;
IF shiftup<clr THEN shiftup:=clr;
clr:=mem[x+2].int+(fontinfo[5+parambase[eqtb[2896+
cursize].hh.rh]].int DIV 4);
IF shiftup<clr THEN shiftup:=clr;
END;
IF mem[q+3].hh.rh=0 THEN mem[x+4].int:=-shiftup
ELSE
{651}
BEGIN
y:=Cleanbox(q+3,2*(curstyle DIV 4)+5);
mem[y+1].int:=mem[y+1].int+eqtb[4016].int;
IF shiftdown<fontinfo[17+parambase[eqtb[2896+cursize].hh.rh]].int THEN
shiftdown:=fontinfo[17+parambase[eqtb[2896+cursize].hh.rh]].int;
clr:=4*fontinfo[8+parambase[eqtb[2897+cursize].hh.rh]].int-
((shiftup-mem[x+2].int)-(mem[y+3].int-shiftdown));
IF clr>0 THEN
BEGIN
shiftdown:=shiftdown+clr;
clr:=(4*fontinfo[5+parambase[eqtb[2896+
cursize].hh.rh]].int DIV 5)-(shiftup-mem[x+2].int);
IF clr>0 THEN
BEGIN
shiftup:=shiftup+clr;
shiftdown:=shiftdown-clr;
END;
END;
mem[x+4].int:=delta;
p:=Newkern((shiftup-mem[x+2].int)-(mem[y+3].int-shiftdown));
mem[x].hh.rh:=p;
mem[p].hh.rh:=y;
x:=Vpackage(x,0,1,134217727);
mem[x+4].int:=shiftdown;
END;
END;
IF mem[p+1].int=0 THEN mem[p+1].int:=x
ELSE
BEGIN
p:=mem[p+1].int;
WHILE mem[p].hh.rh<>0 DO p:=mem[p].hh.rh;
mem[p].hh.rh:=x;
END;
82:
z:=Hpack(mem[p+1].int,0,1);
IF mem[z+3].int>maxh THEN maxh:=mem[z+3].int;
IF mem[z+2].int>maxd THEN maxd:=mem[z+2].int;
Freenode(z,7);
80:
r:=q;
rtype:=mem[r].hh.b0;
81:
q:=mem[q].hh.rh;
END;
{652}p:=12003;
mem[p].hh.rh:=0;
q:=mlist;
rtype:=0;
curstyle:=style;
{605}
BEGIN
IF curstyle<4 THEN cursize:=0
ELSE cursize:=16*((curstyle-2) DIV 2);
curmu:=Xovern(fontinfo[6+parambase[eqtb[2896+curstyle].hh.rh]].int,18);
END;
WHILE q<>0 DO
BEGIN{653}
t:=22;
s:=4;
pen:=10000;
CASE mem[q].hh.b0 OF
15,16,19,20,21:t:=mem[q].hh.b0;
17:BEGIN
t:=17;
pen:=eqtb[3592].int;
END;
18:BEGIN
t:=18;
pen:=eqtb[3593].int;
END;
22,28,26,25:;
23:s:=5;
27:s:=5;
24:s:=6;
29,30:{654}BEGIN
IF style<4 THEN cursize:=0
ELSE cursize:=16*((style-2) DIV 2);
delta2:=maxd+fontinfo[22+parambase[eqtb[2896+cursize].hh.rh]].int;
delta1:=maxh+maxd-delta2;
IF delta2>delta1 THEN delta1:=delta2;
delta:=(eqtb[3601].int*delta1)DIV 500;
delta2:=delta1+delta1-eqtb[4014].int;
IF delta<delta2 THEN delta:=delta2;
mem[p+1].int:=Vardelimiter(q+1,cursize,delta);
t:=mem[q].hh.b0-(10);
END;
14:{655}BEGIN
curstyle:=mem[q].hh.b1;
s:=2;
{605}
BEGIN
IF curstyle<4 THEN cursize:=0
ELSE cursize:=16*((curstyle-2) DIV 2);
curmu:=Xovern(fontinfo[6+parambase[eqtb[2896+curstyle].hh.rh]].int,18);
END;
GOTO 83;
END;
8,12,2,7,9,10:BEGIN
mem[p].hh.rh:=q;
q:=mem[q].hh.rh;
mem[p].hh.rh:=0;
GOTO 30;
END;
OTHERS:Confusion(624)
END;
{658}
IF rtype>0 THEN
BEGIN
CASE strpool[rtype*8+t+magicoffset]OF
48:x:=0
;
49:IF curstyle<4 THEN
x:=14
ELSE
x:=0;
50:x:=14;
51:IF curstyle<4 THEN
x:=15
ELSE
x:=0;
52:x:=16;
OTHERS:Confusion(626)
END;
IF x<>0 THEN
BEGIN
y:=Mathglue(eqtb[2361+x].hh.rh,curmu);
z:=Newglue(y);
Deletegluere(y);
mem[p].hh.rh:=z;
p:=z;
mem[z].hh.b1:=x+1;
END;
END;
{659}
IF mem[p+1].int<>0 THEN
BEGIN
mem[p].hh.rh:=mem[p+1].int;
REPEAT
p:=mem[p].hh.rh;
UNTIL mem[p].hh.rh=0;
END;
IF(pen<10000)AND penalties AND(mem[q].hh.rh<>0)THEN
BEGIN
rtype:=mem[mem[q].hh.rh].hh.b0;
IF(rtype<>12)AND(rtype<>18)THEN
BEGIN
z:=Newpenalty(pen);
mem[p].hh.rh:=z;
p:=z;
END;
END;
rtype:=t;
83:
r:=q;
q:=mem[q].hh.rh;
Freenode(r,s);
30:
END;
Mlisttohlist:=mem[12003].hh.rh;
END;
{664}PROCEDURE Pushalignmen;
VAR
p:halfword;
BEGIN
p:=Getnode(3);
mem[p].hh.rh:=alignptr;
mem[p].hh.lh:=curalign;
mem[p+1].hh.lh:=mem[12009].hh.rh;
mem[p+1].hh.rh:=curspan;
mem[p+2].int:=alignstate;
alignptr:=p;
END;
PROCEDURE Popalignment;
VAR
p:halfword;
BEGIN
p:=alignptr;
alignstate:=mem[p+2].int;
curspan:=mem[p+1].hh.rh;
mem[12009].hh.rh:=mem[p+1].hh.lh;
curalign:=mem[p].hh.lh;
alignptr:=mem[p].hh.rh;
Freenode(p,3);
END;
{666}{673}
PROCEDURE Getpreamblet;
LABEL
21;
BEGIN
21:
Gettoken;
IF(curcmd=73)AND(curchr=10)THEN
BEGIN
Scanoptional;
Scanglue(false);
Eqdefine(2371,98,curval);
GOTO 21;
END;
IF(curchr=128)AND(curcmd=4)THEN
BEGIN
Printnl(631);
BEGIN
helpptr:=2;
helpline[1]:=632;
helpline[0]:=633;
END;
Error;
GOTO 21;
END;
END;
PROCEDURE Alignpeek;
FORWARD;
PROCEDURE Offsave;
FORWARD;
PROCEDURE Initalign;
LABEL
30,31,32,22;
VAR
savecsptr:halfword;
p:halfword;
BEGIN
savecsptr:=csptr;
Pushalignmen;
alignstate:=-1000000;
{668}
IF(curlist.modefield=185)AND((curlist.tailfield<>curlist.headfield)
OR(curlist.auxfield<>0))THEN
BEGIN
Printnl(627);
BEGIN
helpptr:=3;
helpline[2]:=628;
helpline[1]:=629;
helpline[0]:=630;
END;
Error;
p:=Mlisttohlist(curlist.headfield,0,false);
Flushnodelis(p);
curlist.tailfield:=curlist.headfield;
p:=Mlisttohlist(curlist.auxfield,0,false);
Flushnodelis(p);
END;
Pushnest;
{667}
IF curlist.modefield=185 THEN
BEGIN
curlist.modefield:=-1;
curlist.auxfield:=nest[nestptr-2].auxfield;
END
ELSE
BEGIN
IF curlist.modefield>0 THEN
curlist.modefield:=-curlist.
modefield;
IF curlist.modefield=-93 THEN
curlist.auxfield:=1000;
END;
Scanspec;
Newsavelevel(8);
{669}mem[12009].hh.rh:=0;
curalign:=12009;
scannerstatu:=4;
warningindex:=savecsptr;
WHILE true DO
BEGIN{670}
mem[curalign].hh.rh:=Newparamglue(10);
curalign:=mem[curalign].hh.rh;
IF curcmd=5 THEN
GOTO 30;
{671}{674}p:=12004;
mem[p].hh.rh:=0;
WHILE true DO
BEGIN
Getpreamblet;
IF curcmd=6 THEN
GOTO 31;
IF(curcmd<=5)AND(curcmd>=4)THEN
BEGIN
Printnl(634);
BEGIN
helpptr:=3;
helpline[2]:=635;
helpline[1]:=636;
helpline[0]:=637;
END;
Backerror;
GOTO 31;
END;
IF(curcmd<>10)OR(p<>12004)THEN
BEGIN
mem[p].hh.rh:=Getavail;
p:=mem[p].hh.rh;
mem[p].hh.lh:=curtok;
END;
END;
31:;
mem[curalign].hh.rh:=Newnullbox;
curalign:=mem[curalign].hh.rh;
mem[curalign].hh.lh:=12010;
mem[curalign+1].int:=-1073741824;
mem[curalign+3].int:=mem[12004].hh.rh;
{675}p:=12004;
mem[p].hh.rh:=0;
WHILE true DO
BEGIN
22:
Getpreamblet;
IF(curcmd<=5)AND(curcmd>=4)AND(alignstate=-1000000)THEN
GOTO 32;
IF curcmd=6 THEN
BEGIN
Printnl(638);
BEGIN
helpptr:=3;
helpline[2]:=635;
helpline[1]:=636;
helpline[0]:=639;
END;
GOTO 22;
END;
mem[p].hh.rh:=Getavail;
p:=mem[p].hh.rh;
mem[p].hh.lh:=curtok;
END;
32:
mem[p].hh.rh:=Getavail;
p:=mem[p].hh.rh;
mem[p].hh.lh:=2304;
mem[curalign+2].int:=mem[12004].hh.rh;
END;
30:
scannerstatu:=0;
Alignpeek;
END;
{677}{678}
PROCEDURE Initspan(p:halfword);
BEGIN
Pushnest;
IF curlist.modefield=-1 THEN
curlist.auxfield:=-65536000
ELSE
curlist.
auxfield:=1000;
curspan:=p;
END;
PROCEDURE Initrow;
BEGIN
Pushnest;
curlist.modefield:=(-94)-curlist.modefield;
BEGIN
mem[curlist.tailfield].hh.rh:=Newglue(mem[mem[12009].hh.rh+1].hh.
lh);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b1:=11;
curalign:=mem[mem[12009].hh.rh].hh.rh;
Initspan(curalign);
END;
{679}
PROCEDURE Initcol;
BEGIN
mem[curalign+5].hh.lh:=curcmd;
IF curcmd=62 THEN
alignstate:=0
ELSE
BEGIN
Backinput;
Begintokenli(mem[curalign+3].int,1);
alignstate:=1000000;
END;
END;
{682}
FUNCTION Fincol:boolean;
VAR
p:halfword;
q:halfword;
s:halfword;
u:halfword;
w:scaled;
o:glueord;
n:halfword;
BEGIN
IF(curalign=0)OR(mem[curalign].hh.rh=0)THEN
Confusion(640);
p:=mem[mem[curalign].hh.rh].hh.rh;
{683}
IF(p=0)AND(mem[curalign+5].hh.lh<>129)THEN
BEGIN
Printnl(641);
BEGIN
helpptr:=3;
helpline[2]:=642;
helpline[1]:=643;
helpline[0]:=644;
END;
mem[curalign+5].hh.lh:=129;
Error;
END;
;
IF mem[curalign+5].hh.lh<>128 THEN
BEGIN{686}
BEGIN
IF curlist.modefield=
-93 THEN
BEGIN
u:=Hpack(curlist.headfield,0,1);
w:=mem[u+1].int;
END
ELSE
BEGIN
u:=Vpackage(curlist.headfield,0,1,0);
w:=mem[u+3].int;
END;
n:=0;
IF curspan<>curalign THEN
{688}q:=curspan;
REPEAT
n:=n+1;
q:=mem[mem[q].hh.rh].hh.rh;
UNTIL q=curalign;
IF n>255 THEN
Confusion(645);
q:=curspan;
WHILE mem[mem[q].hh.lh].hh.rh<n DO q:=mem[q].hh.lh;
IF mem[mem[q].hh.lh].hh.rh>n THEN
BEGIN
s:=Getnode(2);
mem[s].hh.lh:=mem[q].hh.lh;
mem[s].hh.rh:=n;
mem[q].hh.lh:=s;
mem[s+1].int:=w;
END
ELSE
IF mem[mem[q].hh.lh+1].int<w THEN
mem[mem[q].hh.lh+1].int:=w
ELSE
IF w>mem[curalign+1].int THEN
mem[curalign+1].int:=w;
mem[u].hh.b0:=13;
mem[u].hh.b1:=n;
{565}
IF totalstretch[3]<>0 THEN
o:=3
ELSE
IF totalstretch[2]<>0 THEN
o:=
2
ELSE
IF totalstretch[1]<>0 THEN
o:=1
ELSE
o:=0;
mem[u+5].hh.b1:=o;
mem[u+6].int:=totalstretch[o];
{571}
IF totalshrink[3]<>0 THEN
o:=3
ELSE
IF totalshrink[2]<>0 THEN
o:=2
ELSE
IF totalshrink[1]<>0 THEN
o:=1
ELSE
o:=0;
mem[u+5].hh.b0:=o;
mem[u+4].int:=totalshrink[o];
Popnest;
mem[curlist.tailfield].hh.rh:=u;
curlist.tailfield:=u;
END;
{684}
BEGIN
mem[curlist.tailfield].hh.rh:=Newglue(mem[mem[curalign].hh.rh
+1].hh.lh);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b1:=11;
IF mem[curalign+5].hh.lh=129 THEN
{685}
BEGIN
curalign:=p;
WHILE curalign<>0 DO
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=
Newnullbox;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b0:=13;
IF mem[curalign+1].int<0 THEN
mem[curalign+1].int:=0;
{684}
BEGIN
mem[curlist.tailfield].hh.rh:=Newglue(mem[mem[curalign].hh.rh
+1].hh.lh);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b1:=11;
curalign:=mem[mem[curalign].hh.rh].hh.rh;
END;
Fincol:=true;
GOTO 10;
END;
Initspan(p);
END;
{362}
REPEAT
Getnctoken;
UNTIL curcmd<>10;
curalign:=p;
Initcol;
Fincol:=false;
10:
END;
{689}PROCEDURE Finrow;
VAR
p:halfword;
BEGIN
IF curlist.modefield=-93 THEN
BEGIN
p:=Hpack(mem[curlist.headfield
].hh.rh,0,1);
Popnest;
Appendtovlis(p);
END
ELSE
BEGIN
p:=Vpackage(mem[curlist.headfield].hh.rh,0,1,134217727);
Popnest;
mem[curlist.tailfield].hh.rh:=p;
curlist.tailfield:=p;
curlist.auxfield:=1000;
END;
mem[p].hh.b0:=13;
mem[p+6].int:=0;
Alignpeek;
END;
{690}
PROCEDURE Doassignment;
FORWARD;
PROCEDURE Resumeafterd;
FORWARD;
PROCEDURE Buildpage;
FORWARD;
PROCEDURE Finalign;
VAR
p,q,r,s,u:halfword;
t:scaled;
n:halfword;
BEGIN
IF curgroup<>8 THEN
Confusion(646);
Unsave;
{691}q:=mem[mem[12009].hh.rh].hh.rh;
REPEAT
Flushlist(mem[q+3].int);
Flushlist(mem[q+2].int);
p:=mem[mem[q].hh.rh].hh.rh;
IF mem[q+1].int=-1073741824 THEN
mem[q+1].int:=0;
IF(p<>0)AND(mem[q].hh.lh<>12010)THEN
{692}
BEGIN
t:=mem[q+1].int+mem[mem[mem[q].hh.rh+1].hh.lh+1].int;
r:=mem[q].hh.lh;
s:=12010;
mem[s].hh.lh:=p;
n:=1;
REPEAT
mem[r+1].int:=mem[r+1].int-t;
u:=mem[r].hh.lh;
WHILE mem[r].hh.rh>n DO
BEGIN
s:=mem[s].hh.lh;
n:=mem[mem[s].hh.lh].hh.rh+1;
END;
IF mem[r].hh.rh<n THEN
BEGIN
mem[r].hh.lh:=mem[s].hh.lh;
mem[s].hh.lh:=r;
mem[r].hh.rh:=mem[r].hh.rh-1;
s:=r;
END
ELSE
BEGIN
IF mem[r+1].int>mem[mem[s].hh.lh+1].int THEN
mem[mem[s].
hh.lh+1].int:=mem[r+1].int;
Freenode(r,2);
END;
r:=u;
UNTIL r=12010;
END;
mem[q].hh.b0:=13;
mem[q].hh.b1:=0;
mem[q+3].int:=mem[q+1].int;
mem[q+2].int:=0;
mem[q+5].hh.b1:=0;
mem[q+5].hh.b0:=0;
q:=p;
UNTIL q=0;
{693}saveptr:=saveptr-2;
IF curlist.modefield=-93 THEN
p:=Hpack(mem[12009].hh.rh,savestack[
saveptr+1].int,savestack[saveptr+0].int)
ELSE
p:=Vpackage(mem[12009].hh.
rh,savestack[saveptr+1].int,savestack[saveptr+0].int,134217727);
q:=p+5;
REPEAT
q:=mem[q].hh.rh;
r:=mem[q+1].hh.lh;
mem[q].hh.b0:=10;
mem[q].hh.b1:=0;
IF mem[p+5].hh.b0=0 THEN
mem[q+1].int:=mem[r+1].int
ELSE
IF mem[p+5].hh.
b0=1 THEN
IF mem[r].hh.b0<>mem[p+5].hh.b1 THEN
mem[q+1].int:=mem[r+1].
int
ELSE
mem[q+1].int:=mem[q+1].int+Round(mem[p+6].gr*mem[r+2].int)
ELSE
IF mem[r].hh.b1<>mem[p+5].hh.b1 THEN
mem[q+1].int:=mem[r+1].int
ELSE
mem
[q+1].int:=mem[q+1].int-Round(mem[p+6].gr*mem[r+3].int);
Deletegluere(r);
q:=mem[q].hh.rh;
UNTIL q=0;
{694}q:=mem[curlist.headfield].hh.rh;
WHILE q<>0 DO
BEGIN
IF mem[q].hh.b0=13 THEN
{695}
BEGIN
IF curlist.
modefield=-1 THEN
BEGIN
mem[q].hh.b0:=0;
mem[q+1].int:=mem[p+1].int;
END
ELSE
BEGIN
mem[q].hh.b0:=1;
mem[q+3].int:=mem[p+3].int;
END;
mem[q+5].hh.b1:=mem[p+5].hh.b1;
mem[q+5].hh.b0:=mem[p+5].hh.b0;
mem[q+6].gr:=mem[p+6].gr;
mem[q+4].int:=0;
r:=mem[mem[q+5].hh.rh].hh.rh;
s:=mem[mem[p+5].hh.rh].hh.rh;
REPEAT{696}
n:=mem[r].hh.b1;
t:=mem[s+1].int;
WHILE n>0 DO
BEGIN
n:=n-1;
s:=mem[s].hh.rh;
t:=t+mem[s+1].int;
s:=mem[s].hh.rh;
t:=t+mem[s+1].int;
END;
IF curlist.modefield=-1 THEN
{697}
BEGIN
mem[r+3].int:=mem[q+3].int;
mem[r+2].int:=mem[q+2].int;
IF t=mem[r+1].int THEN
BEGIN
mem[r+5].hh.b0:=0;
mem[r+5].hh.b1:=0;
mem[r+6].gr:=0.0;
END
ELSE
IF t>mem[r+1].int THEN
BEGIN
mem[r+5].hh.b0:=1;
IF mem[r+6].int=0 THEN
mem[r+6].gr:=0.0
ELSE
mem[r+6].gr:=(t-mem[r+1].
int)/mem[r+6].int;
END
ELSE
BEGIN
mem[r+5].hh.b1:=mem[r+5].hh.b0;
mem[r+5].hh.b0:=2;
IF mem[r+4].int=0 THEN
mem[r+6].gr:=0.0
ELSE
mem[r+6].gr:=(mem[r+1].int-
t)/mem[r+4].int;
END;
mem[r+1].int:=t;
mem[r].hh.b0:=0;
END
ELSE
{698}
BEGIN
mem[r+1].int:=mem[q+1].int;
IF t=mem[r+3].int THEN
BEGIN
mem[r+5].hh.b0:=0;
mem[r+5].hh.b1:=0;
mem[r+6].gr:=0.0;
END
ELSE
IF t>mem[r+3].int THEN
BEGIN
mem[r+5].hh.b0:=1;
IF mem[r+6].int=0 THEN
mem[r+6].gr:=0.0
ELSE
mem[r+6].gr:=(t-mem[r+3].
int)/mem[r+6].int;
END
ELSE
BEGIN
mem[r+5].hh.b1:=mem[r+5].hh.b0;
mem[r+5].hh.b0:=2;
IF mem[r+4].int=0 THEN
mem[r+6].gr:=0.0
ELSE
mem[r+6].gr:=(mem[r+3].int-
t)/mem[r+4].int;
END;
mem[r+3].int:=t;
mem[r].hh.b0:=1;
END;
mem[r+4].int:=0;
;
r:=mem[mem[r].hh.rh].hh.rh;
s:=mem[mem[s].hh.rh].hh.rh;
UNTIL r=0;
END;
q:=mem[q].hh.rh;
END;
Flushnodelis(p);
Popalignment;
{699}t:=curlist.auxfield;
p:=mem[curlist.headfield].hh.rh;
q:=curlist.tailfield;
Popnest;
IF curlist.modefield=185 THEN
{1071}
BEGIN
Doassignment;
IF curcmd<>3 THEN
{1072}
BEGIN
Printnl(838);
BEGIN
helpptr:=2;
helpline[1]:=628;
helpline[0]:=629;
END;
Backerror;
END
ELSE
{1062}
BEGIN
Getnctoken;
IF curcmd<>3 THEN
BEGIN
Printnl(833);
BEGIN
helpptr:=2;
helpline[1]:=834;
helpline[0]:=835;
END;
Backerror;
END;
END;
Popnest;
BEGIN
mem[curlist.tailfield].hh.rh:=Newpenalty(eqtb[3594].int);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
BEGIN
mem[curlist.tailfield].hh.rh:=Newparamglue(3);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.rh:=p;
IF q<>0 THEN
curlist.tailfield:=q;
BEGIN
mem[curlist.tailfield].hh.rh:=Newpenalty(eqtb[3593].int);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
BEGIN
mem[curlist.tailfield].hh.rh:=Newparamglue(3);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
curlist.auxfield:=t;
Resumeafterd;
IF curgroup<>16 THEN
Confusion(837);
Unsave;
END
ELSE
BEGIN
curlist.auxfield:=t;
mem[curlist.tailfield].hh.rh:=p;
IF q<>0 THEN
curlist.tailfield:=q;
IF curlist.modefield=1 THEN
Buildpage;
END;
END;
{676}
PROCEDURE Alignpeek;
BEGIN{362}
REPEAT
Getnctoken;
UNTIL curcmd<>10;
IF curcmd=34 THEN
BEGIN
Scanleftbrac;
Newsavelevel(9);
END
ELSE
IF curcmd=2 THEN
Finalign
ELSE
BEGIN
Initrow;
Initcol;
END;
END;
{702}
PROCEDURE Linebreak(finalwidowpe:integer);
LABEL
30,31,32,33,34,35,36,37,40,45;
VAR
{708}passive:halfword;
{712}noshrinkerro:boolean;
{716}p:halfword;
secondpass:boolean;
threshold:integer;
{733}easyline:halfword;
lastspeciall:halfword;
firstwidth:scaled;
secondwidth:scaled;
firstindent:scaled;
secondindent:scaled;
{745}autobreaking:boolean;
prevp:halfword;
q,r,s:halfword;
t:quarterword;
f:internalfont;
w:scaled;
pen:integer;
{755}bestbet:halfword;
fewestdemeri:integer;
bestline:halfword;
actualloosen:integer;
linediff:integer;
{759}curline:halfword;
{763}discbreak:boolean;
{772}curwidth:scaled;
curindent:scaled;
{778}i,j,l:smallnumber;
c:0..255;
{788}hyphenpassed:smallnumber;
{795}majortail,minortail:halfword;
{806}z:triepointer;
v:quarterword;
{813}h:hyphpointer;
k:strnumber;
u:poolpointer;
{717}PROCEDURE Trybreak(pi:integer;
breaktype:smallnumber);
LABEL
10,30,22,60;
VAR
r:halfword;
prevr:halfword;
oldl:halfword;
nobreakyet:boolean;
{718}prevprevr:halfword;
s:halfword;
q:halfword;
v:halfword;
t:quarterword;
f:internalfont;
l:halfword;
noderstaysac:boolean;
linewidth:scaled;
fitclass:0..3;
b:halfword;
d:integer;
BEGIN{719}
IF Abs(pi)>=10000 THEN
IF pi>0 THEN
GOTO 10
ELSE
pi:=-10000;
nobreakyet:=true;
prevr:=12007;
oldl:=0;
curactivewid[1]:=activewidth[1];
curactivewid[2]:=activewidth[2];
curactivewid[3]:=activewidth[3];
curactivewid[4]:=activewidth[4];
curactivewid[5]:=activewidth[5];
curactivewid[6]:=activewidth[6];
WHILE true DO
BEGIN
22:
r:=mem[prevr].hh.rh;
{720}
IF mem[r].hh.b0=2 THEN
BEGIN
curactivewid[1]:=curactivewid[1]+mem[r
+1].int;
curactivewid[2]:=curactivewid[2]+mem[r+2].int;
curactivewid[3]:=curactivewid[3]+mem[r+3].int;
curactivewid[4]:=curactivewid[4]+mem[r+4].int;
curactivewid[5]:=curactivewid[5]+mem[r+5].int;
curactivewid[6]:=curactivewid[6]+mem[r+6].int;
prevprevr:=prevr;
prevr:=r;
GOTO 22;
END;
{723}
BEGIN
l:=mem[r+1].hh.lh;
IF l>oldl THEN
BEGIN
IF(minimumdemer<1073741823)AND((oldl<>easyline)OR(r=12007))THEN
{724}
BEGIN
IF nobreakyet THEN
{725}
BEGIN
nobreakyet:=false;
breakwidth[1]:=background[1];
breakwidth[2]:=background[2];
breakwidth[3]:=background[3];
breakwidth[4]:=background[4];
breakwidth[5]:=background[5];
breakwidth[6]:=background[6];
IF(breaktype=0)OR(p=0)THEN
BEGIN
s:=p;
WHILE s<>0 DO
BEGIN
IF(s>12000)THEN
GOTO 30;
CASE mem[s].hh.b0 OF
9:{726}BEGIN
v:=mem[s+1].hh.lh;
breakwidth[1]:=breakwidth[1]-mem[v+1].int;
breakwidth[2+mem[v+5].hh.b1]:=breakwidth[2+mem[v+5].hh.b1]-mem[v+2].int;
breakwidth[6]:=breakwidth[6]-mem[v+3].int;
END;
12:;
11,10:breakwidth[1]:=breakwidth[1]-mem[s+1].int;
OTHERS:GOTO 30
END;
s:=mem[s].hh.rh;
END;
END
ELSE
{727}
BEGIN
t:=mem[p].hh.b1;
s:=p;
WHILE t>0 DO
BEGIN
t:=t-1;
s:=mem[s].hh.rh;
{728}
IF(s>12000)THEN
BEGIN
f:=mem[s].hh.b0;
breakwidth[1]:=breakwidth[1]-fontinfo[widthbase[f]
+fontinfo[charbase[f]+mem[s].hh.b1].qqqq.b0].int;
END
ELSE
CASE mem[s].hh.b0 OF
6:BEGIN
f:=mem[s+1].hh.b0;
breakwidth[1]:=breakwidth[1]-fontinfo[widthbase[f]
+fontinfo[charbase[f]+mem[s+1].hh.b1].qqqq.b0].int;
END;
10:breakwidth[1]:=breakwidth[1]-mem[s+1].int;
OTHERS:Confusion(653)
END;
END;
s:=mem[p+1].hh.rh;
WHILE s<>0 DO
BEGIN{729}
IF(s>12000)THEN
BEGIN
f:=mem[s].hh.b0;
breakwidth[1]:=breakwidth[1]+fontinfo[widthbase[f]
+fontinfo[charbase[f]+mem[s].hh.b1].qqqq.b0].int;
END
ELSE
CASE mem[s].hh.b0 OF
6:BEGIN
f:=mem[s+1].hh.b0;
breakwidth[1]:=breakwidth[1]+fontinfo[widthbase[f]
+fontinfo[charbase[f]+mem[s+1].hh.b1].qqqq.b0].int;
END;
10:breakwidth[1]:=breakwidth[1]+mem[s+1].int;
OTHERS:Confusion(654)
END;
s:=mem[s].hh.rh;
END;
breakwidth[1]:=breakwidth[1]+w;
END;
30:
END;
{730}
IF mem[prevr].hh.b0=2 THEN
BEGIN
mem[prevr+1].int:=mem[prevr+1].int
-curactivewid[1]+breakwidth[1];
mem[prevr+2].int:=mem[prevr+2].int-curactivewid[2]+breakwidth[2];
mem[prevr+3].int:=mem[prevr+3].int-curactivewid[3]+breakwidth[3];
mem[prevr+4].int:=mem[prevr+4].int-curactivewid[4]+breakwidth[4];
mem[prevr+5].int:=mem[prevr+5].int-curactivewid[5]+breakwidth[5];
mem[prevr+6].int:=mem[prevr+6].int-curactivewid[6]+breakwidth[6];
END
ELSE
IF prevr=12007 THEN
BEGIN
activewidth[1]:=breakwidth[1];
activewidth[2]:=breakwidth[2];
activewidth[3]:=breakwidth[3];
activewidth[4]:=breakwidth[4];
activewidth[5]:=breakwidth[5];
activewidth[6]:=breakwidth[6];
END
ELSE
BEGIN
q:=Getnode(7);
mem[q].hh.rh:=r;
mem[q].hh.b0:=2;
mem[q].hh.b1:=0;
mem[q+1].int:=breakwidth[1]-curactivewid[1];
mem[q+2].int:=breakwidth[2]-curactivewid[2];
mem[q+3].int:=breakwidth[3]-curactivewid[3];
mem[q+4].int:=breakwidth[4]-curactivewid[4];
mem[q+5].int:=breakwidth[5]-curactivewid[5];
mem[q+6].int:=breakwidth[6]-curactivewid[6];
mem[prevr].hh.rh:=q;
prevprevr:=prevr;
prevr:=q;
END;
minimumdemer:=minimumdemer+Abs(eqtb[3599].int);
FOR fitclass:=0 TO 3 DO
BEGIN
IF minimaldemer[fitclass]<=minimumdemer
THEN
{732}
BEGIN
q:=Getnode(2);
mem[q].hh.rh:=passive;
passive:=q;
mem[q+1].int:=p;
mem[q].hh.lh:=bestplace[fitclass];
q:=Getnode(3);
mem[q+1].hh.rh:=passive;
mem[q+1].hh.lh:=bestplline[fitclass]+1;
mem[q].hh.b1:=fitclass;
mem[q].hh.b0:=breaktype;
mem[q+2].int:=minimaldemer[fitclass];
mem[q].hh.rh:=r;
mem[prevr].hh.rh:=q;
prevr:=q;
END;
minimaldemer[fitclass]:=1073741823;
END;
minimumdemer:=1073741823;
{731}
IF r<>12007 THEN
BEGIN
q:=Getnode(7);
mem[q].hh.rh:=r;
mem[q].hh.b0:=2;
mem[q].hh.b1:=0;
mem[q+1].int:=curactivewid[1]-breakwidth[1];
mem[q+2].int:=curactivewid[2]-breakwidth[2];
mem[q+3].int:=curactivewid[3]-breakwidth[3];
mem[q+4].int:=curactivewid[4]-breakwidth[4];
mem[q+5].int:=curactivewid[5]-breakwidth[5];
mem[q+6].int:=curactivewid[6]-breakwidth[6];
mem[prevr].hh.rh:=q;
prevprevr:=prevr;
prevr:=q;
END;
END;
IF r=12007 THEN
GOTO 10;
{736}
IF l>easyline THEN
BEGIN
linewidth:=secondwidth;
oldl:=65534;
END
ELSE
BEGIN
oldl:=l;
IF l>lastspeciall THEN
linewidth:=secondwidth
ELSE
IF eqtb[2634].hh.rh=0
THEN
linewidth:=firstwidth
ELSE
linewidth:=mem[eqtb[2634].hh.rh+2*l].int;
END;
END;
END;
{737}
BEGIN
IF curactivewid[1]<linewidth THEN
{738}
IF(curactivewid[3]<>0)
OR(curactivewid[4]<>0)OR(curactivewid[5]<>0)THEN
BEGIN
b:=0;
fitclass:=1;
END
ELSE
BEGIN
b:=Badness(linewidth-curactivewid[1],curactivewid[2]);
IF b>12 THEN
IF b>99 THEN
fitclass:=3
ELSE
fitclass:=2
ELSE
fitclass:=1;
END
ELSE
{739}
BEGIN
IF curactivewid[1]-linewidth>curactivewid[6]THEN
b:=
10001
ELSE
b:=Badness(curactivewid[1]-linewidth,curactivewid[6]);
IF b>12 THEN
fitclass:=0
ELSE
fitclass:=1;
END;
IF(b>10000)OR(pi=-10000)THEN
{740}
BEGIN
IF secondpass AND(minimumdemer=1073741823)
AND(mem[r].hh.rh=12007)AND(prevr=12007)THEN
b:=0
ELSE
IF b>
threshold THEN
GOTO 60;
noderstaysac:=false;
END
ELSE
BEGIN
prevr:=r;
IF b>threshold THEN
GOTO 22;
noderstaysac:=true;
END;
{741}{742}
IF pi>=0 THEN
BEGIN
d:=(eqtb[3585].int+b+pi);
d:=d*d;
END
ELSE
BEGIN
d:=eqtb[3585].int+b;
d:=d*d;
IF pi>-10000 THEN
d:=d-pi*pi;
END;
d:=d+mem[r+2].int;
IF(breaktype=1)AND(mem[r].hh.b0=1)THEN
IF p<>0 THEN
d:=d+eqtb[3597].int
ELSE
d:=d+eqtb[3598].int;
IF Abs(fitclass-mem[r].hh.b1)>1 THEN
d:=d+eqtb[3599].int;
IF d<=minimaldemer[fitclass]THEN
BEGIN
minimaldemer[fitclass]:=d;
bestplace[fitclass]:=mem[r+1].hh.rh;
bestplline[fitclass]:=l;
IF d<minimumdemer THEN
minimumdemer:=d;
END;
IF noderstaysac THEN
GOTO 22;
60:{743}
mem[prevr].hh.rh:=mem[r].hh.rh;
Freenode(r,3);
IF prevr=12007 THEN
{744}
BEGIN
r:=mem[12007].hh.rh;
IF mem[r].hh.b0=2 THEN
BEGIN
activewidth[1]:=activewidth[1]+mem[r+1].int
;
activewidth[2]:=activewidth[2]+mem[r+2].int;
activewidth[3]:=activewidth[3]+mem[r+3].int;
activewidth[4]:=activewidth[4]+mem[r+4].int;
activewidth[5]:=activewidth[5]+mem[r+5].int;
activewidth[6]:=activewidth[6]+mem[r+6].int;
curactivewid[1]:=activewidth[1];
curactivewid[2]:=activewidth[2];
curactivewid[3]:=activewidth[3];
curactivewid[4]:=activewidth[4];
curactivewid[5]:=activewidth[5];
curactivewid[6]:=activewidth[6];
mem[12007].hh.rh:=mem[r].hh.rh;
Freenode(r,7);
END;
END
ELSE
IF mem[prevr].hh.b0=2 THEN
BEGIN
r:=mem[prevr].hh.rh;
IF r=12007 THEN
BEGIN
curactivewid[1]:=curactivewid[1]-mem[prevr+1].int;
curactivewid[2]:=curactivewid[2]-mem[prevr+2].int;
curactivewid[3]:=curactivewid[3]-mem[prevr+3].int;
curactivewid[4]:=curactivewid[4]-mem[prevr+4].int;
curactivewid[5]:=curactivewid[5]-mem[prevr+5].int;
curactivewid[6]:=curactivewid[6]-mem[prevr+6].int;
mem[prevprevr].hh.rh:=12007;
Freenode(prevr,7);
prevr:=prevprevr;
END
ELSE
IF mem[r].hh.b0=2 THEN
BEGIN
curactivewid[1]:=curactivewid[1]+
mem[r+1].int;
curactivewid[2]:=curactivewid[2]+mem[r+2].int;
curactivewid[3]:=curactivewid[3]+mem[r+3].int;
curactivewid[4]:=curactivewid[4]+mem[r+4].int;
curactivewid[5]:=curactivewid[5]+mem[r+5].int;
curactivewid[6]:=curactivewid[6]+mem[r+6].int;
mem[prevr+1].int:=mem[prevr+1].int+mem[r+1].int;
mem[prevr+2].int:=mem[prevr+2].int+mem[r+2].int;
mem[prevr+3].int:=mem[prevr+3].int+mem[r+3].int;
mem[prevr+4].int:=mem[prevr+4].int+mem[r+4].int;
mem[prevr+5].int:=mem[prevr+5].int+mem[r+5].int;
mem[prevr+6].int:=mem[prevr+6].int+mem[r+6].int;
mem[prevr].hh.rh:=mem[r].hh.rh;
Freenode(r,7);
END;
END;
END;
END;
10:
END;
{789}FUNCTION Reconstitute(j,n:smallnumber):smallnumber;
LABEL
22,30;
VAR
p:halfword;
s:halfword;
q:fourquarters;
c:quarterword;
d:quarterword;
w:scaled;
r:0..fontmemsize;
BEGIN{790}
hyphenpassed:=0;
s:=12004;
w:=0;
d:=(hu[j]+0);
c:=d;
WHILE true DO
BEGIN
22:
p:=Getavail;
mem[p].hh.b0:=hf;
mem[p].hh.b1:=c;
mem[s].hh.rh:=p;
{791}
IF j=n THEN
GOTO 30;
q:=fontinfo[charbase[hf]+d].qqqq;
IF((q.b2-0)MOD 4)<>1 THEN
GOTO 30;
r:=ligkernbase[hf]+q.b3;
c:=(hu[j+1]+0);
WHILE true DO
BEGIN
q:=fontinfo[r].qqqq;
IF q.b1=c THEN
IF q.b2<128 THEN
{792}
BEGIN
d:=q.b3;
IF Odd(hyf[j])AND(hyphenpassed=0)THEN
hyphenpassed:=j;
j:=j+1;
s:=p;
GOTO 22;
END
ELSE
BEGIN
w:=fontinfo[kernbase[f]+q.b3].int;
GOTO 30;
END
ELSE
IF q.b0<128 THEN
r:=r+1
ELSE
GOTO 30;
END;
END;
30:;
{793}
IF s<>12004 THEN
BEGIN
p:=Newligature(hf,d,mem[12004].hh.rh);
mem[12004].hh.rh:=p;
END;
{794}
IF w<>0 THEN
mem[mem[12004].hh.rh].hh.rh:=Newkern(w);
Reconstitute:=j;
END;
{714}FUNCTION Finiteshrink(p:halfword):halfword;
VAR
q:halfword;
BEGIN
IF noshrinkerro THEN
BEGIN
noshrinkerro:=false;
BEGIN
helpptr:=5;
helpline[4]:=647;
helpline[3]:=648;
helpline[2]:=649;
helpline[1]:=650;
helpline[0]:=651;
END;
Printnl(652);
Error;
END;
q:=Newspec(p);
mem[q].hh.b1:=0;
Deletegluere(p);
Finiteshrink:=q;
END;
BEGIN
parbeginline:=curlist.mlfield;
{703}mem[12003].hh.rh:=mem[curlist.headfield].hh.rh;
IF(curlist.tailfield>12000)THEN
BEGIN
mem[curlist.tailfield].hh.rh:=
Newpenalty(10000);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END
ELSE
IF(mem[curlist.tailfield].hh.b0<>9)OR(mem[curlist.tailfield].hh.b1>
=100)THEN
BEGIN
mem[curlist.tailfield].hh.rh:=Newpenalty(10000);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END
ELSE
BEGIN
mem[curlist.tailfield].hh.b0:=12;
Deletegluere(mem[curlist.tailfield+1].hh.lh);
mem[curlist.tailfield+1].int:=10000;
END;
mem[curlist.tailfield].hh.rh:=Newparamglue(13);
Popnest;
{713}noshrinkerro:=false;
{715}
IF mem[eqtb[2367].hh.rh].hh.b1<>0 THEN
BEGIN
eqtb[2367].hh.rh:= Finiteshrink(eqtb[2367].hh.rh);
END;
IF mem[eqtb[2368].hh.rh].hh.b1<>0 THEN
BEGIN
eqtb[2368].hh.rh:= Finiteshrink(eqtb[2368].hh.rh);
END;
q:=eqtb[2367].hh.rh;
r:=eqtb[2368].hh.rh;
background[1]:=mem[q+1].int+mem[r+1].int;
background[2]:=0;
background[3]:=0;
background[4]:=0;
background[5]:=0;
background[2+mem[q].hh.b0]:=mem[q+2].int;
background[2+mem[r].hh.b0]:=background[2+mem[r].hh.b0]+mem[r+2].int;
background[6]:=mem[q+3].int+mem[r+3].int;
{722}minimumdemer:=1073741823;
minimaldemer[0]:=1073741823;
minimaldemer[1]:=1073741823;
minimaldemer[2]:=1073741823;
minimaldemer[3]:=1073741823;
{734}
IF eqtb[2634].hh.rh=0 THEN
IF eqtb[4021].int=0 THEN
BEGIN
lastspeciall:=0;
firstwidth:=eqtb[4008].int;
secondwidth:=firstwidth;
END
ELSE
{735}
BEGIN
lastspeciall:=Abs(eqtb[3619].int);
IF eqtb[3619].int<0 THEN
BEGIN
firstwidth:=eqtb[4008].int-Abs(eqtb[4021].int);
IF eqtb[4021].int>=0 THEN firstindent:=eqtb[4021].int
ELSE firstindent:=
0;
secondwidth:=eqtb[4008].int;
secondindent:=0;
END
ELSE
BEGIN
firstwidth:=eqtb[4008].int;
firstindent:=0;
secondwidth:=eqtb[4008].int-Abs(eqtb[4021].int);
IF eqtb[4021].int>=0 THEN secondindent:=eqtb[4021].int
ELSE secondindent:=0;
END;
END
ELSE
BEGIN
lastspeciall:=mem[eqtb[2634].hh.rh].hh.lh-1;
secondwidth:=mem[eqtb[2634].hh.rh+2*(lastspeciall+1)].int;
secondindent:=mem[eqtb[2634].hh.rh+2*lastspeciall+1].int;
END;
IF eqtb[3602].int=0 THEN easyline:=lastspeciall
ELSE easyline:=65535;
{746}threshold:=eqtb[3583].int;
secondpass:=false;
WHILE true DO
BEGIN{747}
q:=Getnode(3);
mem[q].hh.b0:=0;
mem[q].hh.b1:=1;
mem[q].hh.rh:=12007;
mem[q+1].hh.rh:=0;
mem[q+1].hh.lh:=curlist.alreadyfield+1;
mem[q+2].int:=0;
mem[12007].hh.rh:=q;
activewidth[1]:=background[1];
activewidth[2]:=background[2];
activewidth[3]:=background[3];
activewidth[4]:=background[4];
activewidth[5]:=background[5];
activewidth[6]:=background[6];
p:=mem[12003].hh.rh;
autobreaking:=true;
prevp:=p;
WHILE(p<>0)AND(mem[12007].hh.rh<>12007)DO{749}
BEGIN
WHILE(p>12000)DO
{750}BEGIN
f:=mem[p].hh.b0;
activewidth[1]:=activewidth[1]+fontinfo[widthbase[f]+
fontinfo[charbase[f]+mem[p].hh.b1].qqqq.b0].int;
p:=mem[p].hh.rh;
END;
CASE mem[p].hh.b0 OF
0,1,2:activewidth[1]:=activewidth[1]+mem[p+1].int;
8:{1219};
9:BEGIN{751}
IF autobreaking THEN
BEGIN
IF(prevp>12000)THEN Trybreak(0,0)
ELSE IF(mem[prevp].hh.b0<=8)THEN Trybreak(0,0);
END;
{752}
BEGIN
IF mem[mem[p+1].hh.lh].hh.b1<>0 THEN
BEGIN
mem[p+1].hh.lh:=
Finiteshrink(mem[p+1].hh.lh);
END;
q:=mem[p+1].hh.lh;
activewidth[1]:=activewidth[1]+mem[q+1].int;
activewidth[2+mem[q].hh.b0]:=activewidth[2+mem[q].hh.b0]+mem[q+2].int;
activewidth[6]:=activewidth[6]+mem[q+3].int;
END;
IF secondpass AND autobreaking THEN
{779}
BEGIN
s:=mem[p].hh.rh;
IF s<>0 THEN
BEGIN{780}
WHILE true DO
BEGIN
IF(s>12000)THEN
BEGIN
c:=(mem[s].hh.b1-0);
hf:=mem[s].hh.b0;
END
ELSE
IF mem[s].hh.b0=6 THEN
BEGIN
q:=mem[s+1].hh.rh;
c:=(mem[q].hh.b1-0);
hf:=mem[q].hh.b0;
END
ELSE
IF mem[s].hh.b0<>10 THEN GOTO 33
ELSE c:=128;
IF c<128 THEN
IF eqtb[3199+c].hh.rh<>0 THEN
IF(eqtb[3199+c].hh.rh=c)OR(eqtb[3617].int<>0)THEN
GOTO 34
ELSE GOTO 33;
s:=mem[s].hh.rh;
END;
34:
ha:=s;
{781}hn:=0;
WHILE true DO
BEGIN
IF(s>12000)THEN
BEGIN
IF mem[s].hh.b0<>hf THEN GOTO 35;
c:=(mem[s].hh.b1-0);
IF c>=128 THEN GOTO 35;
IF(eqtb[3199+c].hh.rh=0)OR(hn=63)THEN GOTO 35;
hb:=s;
hn:=hn+1;
hu[hn]:=c;
hc[hn]:=eqtb[3199+c].hh.rh;
END
ELSE
IF mem[s].hh.b0=6 THEN
{782}
BEGIN
j:=hn;
q:=mem[s+1].hh.rh;
IF mem[q].hh.b0<>hf THEN GOTO 35;
REPEAT
c:=(mem[q].hh.b1-0);
IF c>=128 THEN GOTO 35;
IF(eqtb[3199+c].hh.rh=0)OR(j=63)THEN GOTO 35;
j:=j+1;
hu[j]:=c;
hc[j]:=eqtb[3199+c].hh.rh;
q:=mem[q].hh.rh;
UNTIL q=0;
hb:=s;
hn:=j;
END
ELSE
IF mem[s].hh.b0<>10 THEN GOTO 35;
s:=mem[s].hh.rh;
END;
35:;
{783}
IF hn<5 THEN GOTO 33;
WHILE true DO
BEGIN
IF NOT((s>12000))THEN
CASE mem[s].hh.b0 OF
6,10:;
9,12,3,5,4:GOTO 36;
OTHERS:GOTO 33
END;
s:=mem[s].hh.rh;
END;
36:;
{807}
FOR j:=0 TO hn DO hyf[j]:=0;
{814}h:=hc[1];
FOR j:=2 TO hn DO h:=(h+h+hc[j])MOD 307;
WHILE true DO
BEGIN{815}
k:=hyphword[h];
IF k=0 THEN GOTO 45;
IF(strstart[k+1]-strstart[k])<hn THEN GOTO 45;
IF(strstart[k+1]-strstart[k])=hn THEN
BEGIN
j:=1;
u:=strstart[k];
REPEAT
IF strpool[u]<hc[j]THEN GOTO 45;
IF strpool[u]>hc[j]THEN GOTO 38;
j:=j+1;
u:=u+1;
UNTIL j>hn;
{816}s:=hyphlist[h];
WHILE s<>0 DO
BEGIN
hyf[mem[s].hh.lh]:=1;
s:=mem[s].hh.rh;
END;
GOTO 40;
END;
38:;
IF h>0 THEN h:=h-1
ELSE h:=307;
END;
45:;
hc[0]:=127;
hc[hn+1]:=127;
hc[hn+2]:=0;
FOR j:=0 TO hn-2 DO
BEGIN
z:=hc[j];
l:=j;
WHILE hc[l]=trie[z].b1 DO
BEGIN
IF trie[z].b0<>0 THEN
{808}
BEGIN
v:=trie[z].b0;
REPEAT
i:=l-hyfdistance[v];
IF hyfnum[v]>hyf[i]THEN hyf[i]:=hyfnum[v];
v:=hyfnext[v];
UNTIL v=0;
END;
l:=l+1;
z:=trie[z].rh+hc[l];
END;
END;
40:
hyf[1]:=0;
hyf[hn-2]:=0;
hyf[hn-1]:=0;
hyf[hn]:=0;
{785}
FOR j:=2 TO hn-3 DO
IF Odd(hyf[j])THEN GOTO 37;
GOTO 33;
37:;
{786}q:=mem[hb].hh.rh;
mem[hb].hh.rh:=0;
s:=p;
WHILE mem[s].hh.rh<>ha DO s:=mem[s].hh.rh;
mem[s].hh.rh:=0;
Flushnodelis(ha);
{796}j:=0;
REPEAT
l:=j;
j:=Reconstitute(j+1,hn);
IF hyphenpassed<>0 THEN
{798}
BEGIN
r:=Getnode(2);
mem[s].hh.rh:=r;
mem[r].hh.rh:=mem[12004].hh.rh;
mem[r].hh.b0:=7;
BEGIN
majortail:=mem[12004].hh.rh;
IF mem[majortail].hh.rh<>0 THEN
majortail:=mem[majortail].hh.rh;
END;
i:=hyphenpassed;
{799}minortail:=0;
REPEAT
l:=Reconstitute(l+1,i);
IF minortail=0 THEN mem[r+1].hh.lh:=mem[12004].hh.rh
ELSE mem[minortail].hh.rh:=mem[12004].hh.rh;
BEGIN
minortail:=mem[12004].hh.rh;
IF mem[minortail].hh.rh<>0 THEN
minortail:=mem[minortail].hh.rh;
END;
UNTIL l=i;
mem[minortail].hh.rh:=Newcharacter(hf,45);
{800}minortail:=0;
WHILE l<j DO
BEGIN
REPEAT
l:=Reconstitute(l+1,hn);
IF minortail=0 THEN
mem[r+1].hh.rh:=mem[12004].hh.rh
ELSE mem[minortail].hh.rh:=mem[12004].hh.rh;
BEGIN
minortail:=mem[12004].hh.rh;
IF mem[minortail].hh.rh<>0 THEN
minortail:=mem[minortail].hh.rh;
END;
UNTIL l>=j;
WHILE l>j DO
BEGIN
j:=Reconstitute(j+1,hn);
mem[majortail].hh.rh:=mem[12004].hh.rh;
BEGIN
majortail:=mem[12004].hh.rh;
IF mem[majortail].hh.rh<>0 THEN
majortail:=mem[majortail].hh.rh;
END;
END;
END;
{801}i:=0;
s:=r;
WHILE mem[s].hh.rh<>0 DO
BEGIN
i:=i+1;
s:=mem[s].hh.rh;
END;
mem[r].hh.b1:=i;
END
ELSE
BEGIN
mem[s].hh.rh:=mem[12004].hh.rh;
s:=mem[s].hh.rh;
END;
IF Odd(hyf[j])THEN
{802}
BEGIN
r:=Newdisc;
mem[r+1].hh.lh:=Newcharacter(hf,45);
mem[r].hh.rh:=mem[s].hh.rh;
mem[s].hh.rh:=r;
s:=r;
END;
WHILE mem[s].hh.rh<>0 DO s:=mem[s].hh.rh;
UNTIL j=hn;
mem[s].hh.rh:=q;
END;
33:
END;
END;
10:BEGIN
IF NOT(mem[p].hh.rh>12000)AND autobreaking THEN
IF mem[mem[p].hh.rh].hh.b0=9 THEN Trybreak(0,0);
activewidth[1]:=activewidth[1]+mem[p+1].int;
END;
6:BEGIN
f:=mem[p+1].hh.b0;
activewidth[1]:=activewidth[1]+fontinfo[widthbase[f]
+fontinfo[charbase[f]+mem[p+1].hh.b1].qqqq.b0].int;
END;
7:{753}BEGIN
s:=mem[p+1].hh.lh;
IF s=0 THEN
Trybreak(eqtb[3587].int,1)
ELSE
BEGIN
w:=0;
REPEAT{754}
IF(s>12000)THEN
BEGIN
f:=mem[s].hh.b0;
w:=w+fontinfo[widthbase[f]+fontinfo[charbase[f]+
mem[s].hh.b1].qqqq.b0].int;
END
ELSE
CASE mem[s].hh.b0 OF
6:BEGIN
f:=mem[s+1].hh.b0;
w:=w+fontinfo[widthbase[f]+fontinfo[charbase[f]
+mem[s+1].hh.b1].qqqq.b0].int;
END;
10:w:=w+mem[s+1].int;
OTHERS:Confusion(656)
END;
s:=mem[s].hh.rh;
UNTIL s=0;
activewidth[1]:=activewidth[1]+w;
Trybreak(eqtb[3586].int,1);
activewidth[1]:=activewidth[1]-w;
END;
END;
11:BEGIN
autobreaking:=(mem[p].hh.b1=1);
BEGIN
IF NOT(mem[p].hh.rh>12000)AND autobreaking THEN
IF mem[mem[p].hh.rh].hh.b0=9 THEN Trybreak(0,0);
activewidth[1]:=activewidth[1]+mem[p+1].int;
END;
END;
12:Trybreak(mem[p+1].int,0);
4,3,5:;
OTHERS:Confusion(655)
END;
prevp:=p;
p:=mem[p].hh.rh;
END;
IF p=0 THEN
{756}
BEGIN
Trybreak(-10000,1);
IF mem[12007].hh.rh<>12007 THEN
BEGIN{757}
r:=mem[12007].hh.rh;
fewestdemeri:=1073741823;
REPEAT
IF mem[r].hh.b0<>2 THEN
IF mem[r+2].int<fewestdemeri THEN
BEGIN
fewestdemeri:=mem[r+2].int;
bestbet:=r;
END;
r:=mem[r].hh.rh;
UNTIL r=12007;
bestline:=mem[bestbet+1].hh.lh;
IF eqtb[3602].int=0 THEN
GOTO 30;
{758}
BEGIN
r:=mem[12007].hh.rh;
actualloosen:=0;
REPEAT
IF mem[r].hh.b0<>2 THEN
BEGIN
linediff:=mem[p+1].hh.lh-bestline;
IF((linediff<actualloosen)AND(eqtb[3602].int<=linediff))
OR((linediff>actualloosen)AND(eqtb[3602].int>=linediff))THEN
BEGIN
bestbet:=p;
actualloosen:=linediff;
fewestdemeri:=mem[r+2].int;
END
ELSE
IF(linediff=actualloosen)AND(mem[r+2].int<fewestdemeri)THEN
BEGIN
bestbet:=p;
fewestdemeri:=mem[r+2].int;
END;
END;
r:=mem[r].hh.rh;
UNTIL r=12007;
bestline:=mem[bestbet+1].hh.lh;
END;
IF(actualloosen=eqtb[3602].int)OR secondpass THEN
GOTO 30;
END;
END;
{748}q:=mem[12007].hh.rh;
WHILE q<>12007 DO
BEGIN
p:=mem[q].hh.rh;
IF mem[q].hh.b0=2 THEN
Freenode(q,7)
ELSE
Freenode(q,3);
q:=p;
END;
q:=passive;
WHILE q<>0 DO
BEGIN
p:=mem[q].hh.rh;
Freenode(q,2);
q:=p;
END;
threshold:=eqtb[3584].int;
secondpass:=true;
END;
30:;
{760}{761}q:=mem[bestbet+1].hh.rh;
p:=0;
REPEAT
r:=q;
q:=mem[q].hh.lh;
mem[r].hh.lh:=p;
p:=r;
UNTIL q=0;
curline:=curlist.alreadyfield+1;
REPEAT{764}{765}
q:=mem[p+1].int;
discbreak:=false;
IF q<>0 THEN
IF mem[q].hh.b0=9 THEN
BEGIN
Deletegluere(mem[q+1].hh.lh);
mem[q+1].hh.lh:=eqtb[2368].hh.rh;
mem[q].hh.b1:=8;
mem[eqtb[2368].hh.rh].hh.rh:=mem[eqtb[2368].hh.rh].hh.rh+1;
GOTO 32;
END
ELSE
BEGIN
IF mem[q].hh.b0=7 THEN
{766}
BEGIN
t:=mem[q].hh.b1;
{767}
IF t=0 THEN
r:=mem[q].hh.rh
ELSE
BEGIN
WHILE t>1 DO
BEGIN
s:=mem[s]
.hh.rh;
t:=t-1;
END;
IF(s>12000)THEN
s:=mem[s].hh.rh
ELSE
IF mem[s].hh.b0<>10 THEN
s:=mem[s].
hh.rh;
r:=mem[s].hh.rh;
mem[s].hh.rh:=0;
Flushnodelis(mem[q].hh.rh);
mem[q].hh.b1:=0;
END;
IF mem[q+1].hh.rh<>0 THEN
{768}
BEGIN
s:=mem[q+1].hh.rh;
WHILE mem[s].hh.rh<>0 DO s:=mem[s].hh.rh;
mem[s].hh.rh:=r;
r:=mem[q+1].hh.rh;
mem[q+1].hh.rh:=0;
END;
IF mem[q+1].hh.lh<>0 THEN
{769}
BEGIN
s:=mem[q+1].hh.lh;
mem[q].hh.rh:=s;
WHILE mem[s].hh.rh<>0 DO s:=mem[s].hh.rh;
mem[q+1].hh.lh:=0;
q:=s;
END;
mem[q].hh.rh:=r;
discbreak:=true;
END;
IF(mem[q].hh.b0=11)OR(mem[q].hh.b0=10)THEN
mem[q+1].int:=0;
END
ELSE
BEGIN
q:=12003;
WHILE mem[q].hh.rh<>0 DO q:=mem[q].hh.rh;
END;
{770}r:=Newparamglue(7);
mem[r].hh.rh:=mem[q].hh.rh;
mem[q].hh.rh:=r;
q:=r;
32:;
{771}r:=mem[q].hh.rh;
mem[q].hh.rh:=0;
q:=mem[12003].hh.rh;
mem[12003].hh.rh:=r;
IF eqtb[2367].hh.rh<>0 THEN
BEGIN
r:=Newparamglue(6);
mem[r].hh.rh:=q;
q:=r;
END;
{773}
IF curline>lastspeciall THEN
BEGIN
curwidth:=secondwidth;
curindent:=secondindent;
END
ELSE
IF eqtb[2634].hh.rh=0 THEN
BEGIN
curwidth:=firstwidth;
curindent:=firstindent;
END
ELSE
BEGIN
curwidth:=mem[eqtb[2634].hh.rh+2*curline].int;
curindent:=mem[eqtb[2634].hh.rh+2*curline-1].int;
END;
justbox:=Hpack(q,curwidth,0);
mem[justbox+4].int:=curindent;
{774}Appendtovlis(justbox);
IF mem[12006].hh.rh<>0 THEN
BEGIN
mem[curlist.tailfield].hh.rh:=mem[
12006].hh.rh;
REPEAT
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
UNTIL mem[curlist.tailfield].hh.rh=0;
END;
{775}pen:=eqtb[3596].int;
IF(curline=curlist.alreadyfield+1)AND(bestline<>curlist.alreadyfield+2)
THEN
pen:=pen+eqtb[3588].int;
IF curline+2=bestline THEN
pen:=pen+finalwidowpe;
IF discbreak THEN
pen:=pen+eqtb[3590].int;
IF pen<>0 THEN
BEGIN
r:=Newpenalty(pen);
mem[curlist.tailfield].hh.rh:=r;
curlist.tailfield:=r;
END;
curline:=curline+1;
p:=mem[p].hh.lh;
{762}r:=12003;
WHILE true DO
BEGIN
q:=mem[r].hh.rh;
IF q=mem[p+1].int THEN
GOTO 31;
IF(q>12000)THEN
GOTO 31;
IF(mem[q].hh.b0<=8)THEN
GOTO 31;
r:=q;
END;
31:
IF r<>12003 THEN
BEGIN
mem[r].hh.rh:=0;
Flushnodelis(mem[12003].hh.rh);
mem[12003].hh.rh:=q;
END;
UNTIL p=0;
IF(curline<>bestline)OR(mem[12003].hh.rh<>0)THEN
Confusion(657);
curlist.alreadyfield:=bestline-1;
{748}q:=mem[12007].hh.rh;
WHILE q<>12007 DO
BEGIN
p:=mem[q].hh.rh;
IF mem[q].hh.b0=2 THEN
Freenode(q,7)
ELSE
Freenode(q,3);
q:=p;
END;
q:=passive;
WHILE q<>0 DO
BEGIN
p:=mem[q].hh.rh;
Freenode(q,2);
q:=p;
END;
parbeginline:=0;
END;
{817}PROCEDURE Newhyphexcep;
LABEL
10,40,45;
VAR
n:smallnumber;
j:smallnumber;
h:hyphpointer;
k:strnumber;
p:halfword;
q:halfword;
s,t:strnumber;
u,v:poolpointer;
BEGIN
Scanleftbrac;
{818}n:=0;
p:=0;
WHILE true DO
BEGIN
Getnctoken;
CASE curcmd OF
11,12:{820}IF curchr=45 THEN
{821}
BEGIN
IF n>1 THEN
BEGIN
q:=Getavail;
mem[q].hh.rh:=p;
mem[q].hh.lh:=n;
p:=q;
END;
END
ELSE
BEGIN
IF eqtb[3199+curchr].hh.rh=0 THEN
BEGIN
Printnl(661);
BEGIN
helpptr:=2;
helpline[1]:=662;
helpline[0]:=663;
END;
Error;
END
ELSE
IF n<63 THEN
BEGIN
n:=n+1;
hc[n]:=eqtb[3199+curchr].hh.rh;
END;
END;
10,2:BEGIN
IF n>4 THEN
{822}
BEGIN
BEGIN
IF poolptr+n>poolsize THEN
Overflow(129,poolsize);
END;
h:=0;
FOR j:=1 TO n DO
BEGIN
h:=(h+h+hc[j])MOD 307;
BEGIN
strpool[poolptr]:=hc[j];
poolptr:=poolptr+1;
END;
END;
s:=Makestring;
WHILE mem[p].hh.lh>n-3 DO
BEGIN
q:=mem[p].hh.rh;
BEGIN
mem[p].hh.rh:=avail;
avail:=p;
{DYNUSED:=DYNUSED-1;}
END;
p:=q;
END;
{823}
IF hyphcount=307 THEN
Overflow(664,307);
hyphcount:=hyphcount+1;
WHILE hyphword[h]<>0 DO
BEGIN{824}
k:=hyphword[h];
IF(strstart[k+1]-strstart[k])<(strstart[s+1]-strstart[s])THEN
GOTO 40;
IF(strstart[k+1]-strstart[k])>(strstart[s+1]-strstart[s])THEN
GOTO 45;
u:=strstart[k];
v:=strstart[s];
REPEAT
IF strpool[u]<strpool[v]THEN
GOTO 40;
IF strpool[u]>strpool[v]THEN
GOTO 45;
u:=u+1;
v:=v+1;
UNTIL u=strstart[k+1];
40:
q:=hyphlist[h];
hyphlist[h]:=p;
p:=q;
t:=hyphword[h];
hyphword[h]:=s;
s:=t;
45:;
IF h>0 THEN
h:=h-1
ELSE
h:=307;
END;
hyphword[h]:=s;
hyphlist[h]:=p;
END;
IF curcmd=2 THEN
BEGIN{365}
BEGIN
Getnctoken;
IF curcmd<>10 THEN
Backinput;
END;
GOTO 10;
END;
n:=0;
p:=0;
END;
OTHERS:{819}BEGIN
BEGIN
helpptr:=2;
helpline[1]:=658;
helpline[0]:=659;
END;
Printnl(660);
Error;
END
END;
END;
;
10:
END;
{825}{827}
FUNCTION Newtrieop(d,n:smallnumber;
v:quarterword):quarterword;
LABEL
10;
VAR
h:0..510;
u:quarterword;
BEGIN
h:=(n+313*d+361*v)MOD 510;
WHILE true DO
BEGIN
u:=trieophash[h];
IF u=0 THEN
BEGIN
IF trieopptr>=254 THEN
BEGIN
trieopptr:=255;
Newtrieop:=0;
GOTO 10;
END;
trieopptr:=trieopptr+1;
hyfdistance[trieopptr]:=d;
hyfnum[trieopptr]:=n;
hyfnext[trieopptr]:=v;
trieophash[h]:=trieopptr;
Newtrieop:=trieopptr;
GOTO 10;
END;
IF(hyfdistance[u]=d)AND(hyfnum[u]=n)AND(hyfnext[u]=v)THEN
BEGIN
Newtrieop:=u;
GOTO 10;
END;
IF h>0 THEN
h:=h-1
ELSE
h:=255;
END;
10:
END;
{830}
FUNCTION Trienode(p:triepointer):triepointer;
LABEL
10;
VAR
h:triepointer;
q:triepointer;
BEGIN
h:=(triec[p]+1009*trieo[p]+2718*triel[p]+3142*trier[p])MOD
triesize;
WHILE true DO
BEGIN
q:=triehash[h];
IF q=0 THEN
BEGIN
triehash[h]:=p;
Trienode:=p;
GOTO 10;
END;
IF(triec[q]=triec[p])AND(trieo[q]=trieo[p])AND(triel[q]=triel[p])AND(
trier[q]=trier[p])THEN
BEGIN
Trienode:=q;
GOTO 10;
END;
IF h>0 THEN
h:=h-1
ELSE
h:=triesize;
END;
10:
END;
{831}
FUNCTION Compresstrie(p:triepointer):triepointer;
BEGIN
IF p=0 THEN
Compresstrie:=0
ELSE
BEGIN
triel[p]:=Compresstrie(
triel[p]);
trier[p]:=Compresstrie(trier[p]);
Compresstrie:=Trienode(p);
END;
END;
{832}
PROCEDURE Initpatternm;
VAR
h:0..510;
p:triepointer;
BEGIN
FOR h:=0 TO 510 DO trieophash[h]:=0;
trieopptr:=0;
triel[0]:=0;
triec[0]:=0;
trieptr:=0;
FOR p:=0 TO triesize DO triehash[p]:=0;
END;
{834}
PROCEDURE Inittriememo;
VAR
p:triepointer;
BEGIN
FOR p:=0 TO trieptr DO triehash[p]:=0;
triemax:=128;
triemin:=128;
trie[0].rh:=1;
trietaken[0]:=false;
FOR p:=1 TO 128 DO
BEGIN
trie[p].lh:=p-1;
trie[p].rh:=p+1;
trietaken[p]:=false;
END;
END;
{836}
PROCEDURE Firstfit(p:triepointer);
LABEL
45,40;
VAR
h:triepointer;
z:triepointer;
q:triepointer;
c:asciicode;
BEGIN
c:=triec[p];
IF c<triemin THEN
triemin:=c;
z:=trie[triemin-1].rh;
WHILE true DO
BEGIN
IF z<c THEN
GOTO 45;
h:=z-c;
{837}
IF triemax<h+128 THEN
BEGIN
IF triesize<=h+128 THEN
Overflow(665,
triesize);
REPEAT
triemax:=triemax+1;
trietaken[triemax]:=false;
trie[triemax].rh:=triemax+1;
trie[triemax].lh:=triemax-1;
UNTIL triemax=h+128;
END;
IF trietaken[h]THEN
GOTO 45;
{838}q:=trier[p];
WHILE q>0 DO
BEGIN
IF trie[h+triec[q]].rh=0 THEN
GOTO 45;
q:=trier[q];
END;
GOTO 40;
45:
z:=trie[z].rh;
END;
40:{839}
trietaken[h]:=true;
triehash[p]:=h;
q:=p;
REPEAT
z:=h+triec[q];
trie[trie[z].rh].lh:=trie[z].lh;
trie[trie[z].lh].rh:=trie[z].rh;
trie[z].rh:=0;
q:=trier[q];
UNTIL q=0;
END;
{840}
PROCEDURE Triepack(p:triepointer);
VAR
q:triepointer;
BEGIN
REPEAT
q:=triel[p];
IF(q>0)AND(triehash[q]=0)THEN
BEGIN
Firstfit(q);
Triepack(q);
END;
p:=trier[p];
UNTIL p=0;
END;
{842}
PROCEDURE Triefix(p:triepointer);
VAR
q:triepointer;
c:asciicode;
z:triepointer;
BEGIN
z:=triehash[p];
WHILE p<>0 DO
BEGIN
q:=triel[p];
c:=triec[p];
trie[z+c].rh:=triehash[q];
trie[z+c].b1:=c;
trie[z+c].b0:=trieo[p];
IF q>0 THEN
Triefix(p);
p:=trier[p];
END;
END;
{843}PROCEDURE Newpatterns;
LABEL
30,31;
VAR
k,l:smallnumber;
digitsensed:boolean;
v:quarterword;
p,q:triepointer;
firstchild:boolean;
c:asciicode;
r,s:triepointer;
h:twohalves;
BEGIN
Scanleftbrac;
Initpatternm;
{844}k:=0;
hyf[0]:=0;
digitsensed:=false;
WHILE true DO
BEGIN
Getnctoken;
CASE curcmd OF
11,12:{845}IF digitsensed OR(curchr<48)OR(curchr>57)THEN
BEGIN
IF curchr=46 THEN
curchr:=127
ELSE
BEGIN
curchr:=eqtb[3199+curchr]
.hh.rh;
IF curchr=0 THEN
BEGIN
Printnl(668);
BEGIN
helpptr:=1;
helpline[0]:=667;
END;
Error;
curchr:=127;
END;
END;
IF k<63 THEN
BEGIN
k:=k+1;
hc[k]:=curchr;
hyf[k]:=0;
digitsensed:=false;
END;
END
ELSE
BEGIN
hyf[k]:=curchr-48;
digitsensed:=true;
END;
10,2:BEGIN
IF k>0 THEN
{846}
BEGIN{848}
l:=k;
v:=0;
WHILE true DO
BEGIN
IF hyf[l]<>0 THEN
v:=Newtrieop(k-l,hyf[l],v);
IF l>0 THEN
l:=l-1
ELSE
GOTO 31;
END;
31:;
q:=0;
WHILE l<k DO
BEGIN
l:=l+1;
c:=hc[l];
p:=triel[q];
firstchild:=true;
WHILE(p>0)AND(c>triec[p])DO
BEGIN
q:=p;
p:=trier[q];
firstchild:=false;
END;
IF(p=0)OR(c<triec[p])THEN
{847}
BEGIN
IF trieptr=triesize THEN
Overflow(
665,triesize);
trieptr:=trieptr+1;
trier[trieptr]:=p;
p:=trieptr;
triel[p]:=0;
IF firstchild THEN
triel[q]:=p
ELSE
trier[q]:=p;
triec[p]:=c;
trieo[p]:=0;
END;
q:=p;
END;
IF trieo[q]<>0 THEN
BEGIN
Printnl(669);
BEGIN
helpptr:=1;
helpline[0]:=667;
END;
Error;
END;
trieo[q]:=v;
END;
IF curcmd=2 THEN
BEGIN{365}
BEGIN
Getnctoken;
IF curcmd<>10 THEN
Backinput;
END;
GOTO 30;
END;
k:=0;
hyf[0]:=0;
digitsensed:=false;
END;
OTHERS:BEGIN
Printnl(666);
BEGIN
helpptr:=1;
helpline[0]:=667;
END;
Error;
Passblock(1);
GOTO 30;
END
END;
END;
30:;
triel[0]:=Compresstrie(triel[0]);
{849}Inittriememo;
IF triel[0]<>0 THEN
BEGIN
Firstfit(triel[0]);
Triepack(triel[0]);
END;
{841}r:=0;
WHILE trietaken[r]DO r:=r+1;
triehash[0]:=r;
Triefix(triel[0]);;
r:=0;
h.rh:=0;
h.b0:=0;
h.b1:=0;
REPEAT
s:=trie[r].rh;
trie[r]:=h;
r:=s;
UNTIL r>triemax;
END;
{851}
FUNCTION Prunepagetop(p:halfword):halfword;
VAR
prevp:halfword;
q:halfword;
BEGIN
prevp:=12003;
mem[12003].hh.rh:=p;
WHILE p<>0 DO
CASE mem[p].hh.b0 OF
0,1,2:{852}BEGIN
q:=Newparamglue(9);
mem[prevp].hh.rh:=q;
mem[q].hh.rh:=p;
q:=mem[q+1].hh.lh;
IF mem[q+1].int>mem[p+3].int THEN
mem[q+1].int:=mem[q+1].int-mem[p+3].
int
ELSE
mem[q+1].int:=0;
p:=0;
END;
8,4,3:BEGIN
prevp:=p;
p:=mem[prevp].hh.rh;
END;
9,10,12:BEGIN
q:=p;
p:=mem[q].hh.rh;
mem[q].hh.rh:=0;
mem[prevp].hh.rh:=p;
Flushnodelis(q);
END;
OTHERS:Confusion(670)
END;
Prunepagetop:=mem[12003].hh.rh;
END;
{853}
FUNCTION Vertbreak(p:halfword;
h:scaled):halfword;
LABEL
30,45,90;
VAR
prevp:halfword;
q,r:halfword;
pi:integer;
b:integer;
leastbadness:integer;
bestplace:halfword;
prevdp:scaled;
BEGIN
prevp:=p;
leastbadness:=1073741823;
activewidth[1]:=0;
activewidth[2]:=0;
activewidth[3]:=0;
activewidth[4]:=0;
activewidth[5]:=0;
activewidth[6]:=0;
prevdp:=0;
WHILE true DO
BEGIN{855}
IF p=0 THEN
pi:=-10000
ELSE
{856}
CASE mem[p].hh.
b0 OF
0,1,2:BEGIN
activewidth[1]:=activewidth[1]+prevdp+mem[p+3].int;
prevdp:=mem[p+2].int;
IF prevdp>eqtb[4011].int THEN
BEGIN
activewidth[1]:=activewidth[1]+
prevdp-eqtb[4011].int;
prevdp:=eqtb[4011].int;
END;
GOTO 45;
END;
8:{1221}GOTO 45;
9:IF(mem[prevp].hh.b0<=8)THEN
pi:=0
ELSE
GOTO 90;
10:BEGIN
activewidth[1]:=activewidth[1]+prevdp+mem[p+1].int;
prevdp:=0;
IF mem[p].hh.rh=0 THEN
GOTO 45;
IF mem[p].hh.b0=9 THEN
pi:=0
ELSE
GOTO 45;
END;
12:pi:=mem[p+1].int;
4,3:GOTO 45;
OTHERS:Confusion(671)
END;
{857}
IF pi<10000 THEN
BEGIN{858}
IF activewidth[1]<h THEN
IF(activewidth[3]<>0)OR(activewidth[4]<>0)
OR(activewidth[5]<>0)THEN
b:=0
ELSE
b:=
Badness(h-activewidth[1],activewidth[2])
ELSE
IF activewidth[1]-h>
activewidth[6]THEN
b:=1073741823
ELSE
b:=Badness(activewidth[1]-h,
activewidth[6]);
IF b<=10000 THEN
IF pi<=-10000 THEN
b:=pi
ELSE
b:=b+pi;
IF b<=leastbadness THEN
BEGIN
bestplace:=p;
leastbadness:=b;
bestheight:=activewidth[1];
END;
IF(b=1073741823)OR(pi<=-10000)THEN
GOTO 30;
END;
IF mem[p].hh.b0<>9 THEN
GOTO 45;
90:{859}
q:=mem[p+1].hh.lh;
activewidth[1]:=activewidth[1]+prevdp+mem[q+1].int;
prevdp:=0;
activewidth[2+mem[q].hh.b0]:=activewidth[2+mem[q].hh.b0]+mem[q+2].int;
activewidth[6]:=activewidth[6]+mem[q+3].int;
IF mem[q].hh.b1<>0 THEN
BEGIN
Printnl(672);
BEGIN
helpptr:=4;
helpline[3]:=673;
helpline[2]:=674;
helpline[1]:=675;
helpline[0]:=651;
END;
Error;
r:=Newspec(q);
mem[r].hh.b1:=0;
Deletegluere(q);
mem[p+1].hh.lh:=r;
END;
45:;
prevp:=p;
p:=mem[prevp].hh.rh;
END;
30:
Vertbreak:=bestplace;
END;
{860}
FUNCTION Vsplit(n:quarterword;
h:scaled):halfword;
LABEL
10,30;
VAR
v:halfword;
p:halfword;
q:halfword;
BEGIN
v:=eqtb[2637+n].hh.rh;
IF curmark[3]<>0 THEN
BEGIN
Deletetokenr(curmark[3]);
curmark[3]:=0;
Deletetokenr(curmark[4]);
curmark[4]:=0;
END;
{861}
IF v=0 THEN
BEGIN
Vsplit:=0;
GOTO 10;
END;
IF mem[v].hh.b0<>1 THEN
BEGIN
BEGIN
helpptr:=2;
helpline[1]:=676;
helpline[0]:=677;
END;
Printnl(678);
Error;
Vsplit:=0;
GOTO 10;
END;
q:=Vertbreak(mem[v+5].hh.rh,h);
{862}p:=mem[v+5].hh.rh;
IF p=q THEN
mem[v+5].hh.rh:=0
ELSE
WHILE true DO
BEGIN
IF mem[p].hh.b0=4
THEN
IF curmark[3]=0 THEN
BEGIN
curmark[3]:=mem[p+1].int;
curmark[4]:=curmark[3];
mem[curmark[3]].hh.lh:=mem[curmark[3]].hh.lh+2;
END
ELSE
BEGIN
Deletetokenr(curmark[4]);
curmark[4]:=mem[p+1].int;
mem[curmark[4]].hh.lh:=mem[curmark[4]].hh.lh+1;
END;
IF mem[p].hh.rh=q THEN
BEGIN
mem[p].hh.rh:=0;
GOTO 30;
END;
p:=mem[p].hh.rh;
END;
30:;
q:=Prunepagetop(q);
p:=mem[v+5].hh.rh;
Freenode(v,7);
IF q=0 THEN
eqtb[2637+n].hh.rh:=0
ELSE
eqtb[2637+n].hh.rh:=Vpackage(q,0,
1,134217727);
Vsplit:=Vpackage(p,h,0,eqtb[4011].int);
10:
END;
{870}PROCEDURE Buildpage;
LABEL
10,30,31,80,90;
VAR
p:halfword;
q,r,s:halfword;
prevp:halfword;
b:integer;
pi:integer;
n:0..255;
delta,h,w:scaled;
wait:boolean;
BEGIN
IF(mem[12001].hh.rh=0)OR outputactive THEN
GOTO 10;
REPEAT
p:=mem[12001].hh.rh;
{872}
IF lastpageglue<>65535 THEN
Deletegluere(lastpageglue);
IF mem[p].hh.b0=9 THEN
BEGIN
lastpageglue:=mem[p+1].hh.lh;
mem[lastpageglue].hh.rh:=mem[lastpageglue].hh.rh+1;
END;
{873}{876}
CASE p OF
0,1,2:IF emptypage THEN
{877}
BEGIN
pagesize:=eqtb[
4009].int;
pagedepthmax:=eqtb[4010].int;
curpagedepth:=0;
pagesofar[1]:=0;
pagesofar[2]:=0;
pagesofar[3]:=0;
pagesofar[4]:=0;
pagesofar[5]:=0;
pagesofar[6]:=0;
leastpagebad:=1073741823;
emptypage:=false;
q:=Newparamglue(8);
mem[q].hh.rh:=p;
r:=mem[q+1].hh.lh;
IF mem[r+1].int>mem[p+3].int THEN
mem[r+1].int:=mem[r+1].int-mem[p+3].
int
ELSE
mem[r+1].int:=0;
p:=q;
GOTO 90;
END
ELSE
{878}
BEGIN
pagesofar[1]:=pagesofar[1]+curpagedepth+mem[p+3].int;
curpagedepth:=mem[p+2].int;
IF curpagedepth>pagedepthmax THEN
BEGIN
pagesofar[1]:=pagesofar[1]+
curpagedepth-pagedepthmax;
curpagedepth:=pagedepthmax;
END;
GOTO 80;
END;
8:{1220}GOTO 80;
9:IF emptypage THEN
GOTO 31
ELSE
IF(mem[pagetail].hh.b0<=8)THEN
pi:=0
ELSE
GOTO 90;
10:IF emptypage THEN
GOTO 31
ELSE
IF mem[p].hh.rh=0 THEN
GOTO 10
ELSE
BEGIN
pagesofar[1]:=pagesofar[1]+curpagedepth+mem[p+1].int;
curpagedepth:=0;
IF mem[p].hh.b0=9 THEN
pi:=0
ELSE
GOTO 80;
END;
12:IF emptypage THEN
GOTO 31
ELSE
pi:=mem[p+1].int;
4:GOTO 80;
3:{882}BEGIN
n:=mem[p].hh.b1;
r:=12000;
WHILE n>=mem[mem[r].hh.rh].hh.b1 DO r:=mem[r].hh.rh;
n:=(n-0);
IF mem[r].hh.b1<>(n+0)THEN
{883}
BEGIN
q:=Getnode(3);
mem[q].hh.rh:=mem[r].hh.rh;
mem[r].hh.rh:=q;
r:=q;
mem[r].hh.b1:=(n+0);
mem[r].hh.b0:=0;
IF eqtb[2637+n].hh.rh=0 THEN mem[r+1].int:=0
ELSE mem[r+1].int:=
mem[eqtb[2637+n].hh.rh+3].int+mem[eqtb[2637+n].hh.rh+2].int;
mem[r+2].hh.lh:=0;
q:=eqtb[2378+n].hh.rh;
pagesize:=
pagesize-mem[q+1].int-(Xovern(mem[r+1].int,1000)*eqtb[3620+n].int);
pagesofar[2+mem[q].hh.b0]:=pagesofar[2+mem[q].hh.b0]+mem[q+2].int;
pagesofar[6]:=pagesofar[6]+mem[q+3].int;
IF mem[q].hh.b1<>0 THEN
BEGIN
Printnl(682);
Printint(n);
BEGIN
helpptr:=3;
helpline[2]:=683;
helpline[1]:=684;
helpline[0]:=651;
END;
Error;
END;
END;
IF mem[r].hh.b0=0 THEN
BEGIN
mem[r+2].hh.rh:=p;
delta:=pagesize-pagesofar[1]+pagesofar[6];
h:=Xovern(mem[p+1].int,1000)*eqtb[3620+n].int;
IF(h<=delta)AND(mem[p+1].int+mem[r+1].int<=eqtb[4022+n].int)THEN
BEGIN
pagesize:=pagesize-h;
mem[r+1].int:=mem[r+1].int+mem[p+1].int;
END
ELSE
{884}
BEGIN
IF eqtb[3620+n].int<=0 THEN
w:=134217727
ELSE
w:=
Xovern(delta,eqtb[3620+n].int)*1000;
IF w>eqtb[4022+n].int-mem[r+1].int THEN
w:=eqtb[4022+n].int-mem[r+1].int
;
q:=Vertbreak(mem[p+2].int,w);
pagesize:=pagesize-bestheight;
mem[r].hh.b0:=1;
mem[r+1].int:=q;
IF q=0 THEN
inspenalties:=inspenalties-10000
ELSE
IF mem[q].hh.b0=12
THEN
inspenalties:=inspenalties+mem[q+1].int;
END;
END;
GOTO 30;
END;
OTHERS:Confusion(679)
END;
{880}
IF pi<10000 THEN
BEGIN{881}
IF pagesofar[1]<pagesize THEN
IF(pagesofar[3]<>0)OR(pagesofar[4]<>0)OR(pagesofar[5]<>0)THEN
b:=0
ELSE
b:=
Badness(pagesize-pagesofar[1],pagesofar[2])
ELSE
IF pagesofar[1]-pagesize
>pagesofar[6]THEN
b:=1073741823
ELSE
b:=Badness(pagesofar[1]-pagesize,
pagesofar[6]);
IF b<=10000 THEN
IF pi<=-10000 THEN
b:=pi
ELSE
b:=b+pi+inspenalties;
IF b<=leastpagebad THEN
BEGIN
bestpagebrea:=p;
bestsize:=pagesize;
leastpagebad:=b;
r:=mem[12000].hh.rh;
WHILE r<>12000 DO
BEGIN
mem[r+2].hh.lh:=mem[r+2].hh.rh;
IF mem[r].hh.b0=1 THEN
mem[r].hh.b0:=2;
r:=mem[r].hh.rh;
END;
END;
IF(b=1073741823)OR(pi<=-10000)THEN
{885}
BEGIN{886}
IF mem[bestpagebrea].hh
.b0=12 THEN
BEGIN
Geqworddefin(3618,mem[bestpagebrea+1].int);
mem[bestpagebrea+1].int:=10000;
END
ELSE
Geqworddefin(3618,10000);
IF curmark[2]<>0 THEN
BEGIN
IF curmark[0]<>0 THEN
Deletetokenr(curmark[0]);
curmark[0]:=curmark[2];
mem[curmark[0]].hh.lh:=mem[curmark[0]].hh.lh+1;
Deletetokenr(curmark[1]);
curmark[1]:=0;
END;
{887}
IF p=bestpagebrea THEN
bestpagebrea:=0;
{888}
IF eqtb[2892].hh.rh<>0 THEN
BEGIN
Printnl(685);
BEGIN
helpptr:=2;
helpline[1]:=686;
helpline[0]:=687;
END;
Error;
Flushnodelis(eqtb[2892].hh.rh);
eqtb[2892].hh.rh:=0;
END;
{891}r:=mem[12000].hh.rh;
WHILE r<>12000 DO
BEGIN
IF mem[r+2].hh.lh<>0 THEN
BEGIN
n:=(mem[r].hh.b1
-0);
IF eqtb[2637+n].hh.rh=0 THEN
eqtb[2637+n].hh.rh:=Newnullbox;
p:=mem[eqtb[2637+n].hh.rh+5].hh.rh;
IF p<>0 THEN
WHILE mem[p].hh.rh<>0 DO p:=mem[p].hh.rh;
mem[r+2].hh.rh:=p;
END;
r:=mem[r].hh.rh;
END;
q:=12003;
mem[q].hh.rh:=0;
prevp:=12002;
p:=mem[prevp].hh.rh;
WHILE p<>bestpagebrea DO
BEGIN
IF mem[p].hh.b0=3 THEN
{893}
BEGIN
r:=mem[
12000].hh.rh;
WHILE mem[r].hh.b1<>mem[p].hh.b1 DO r:=mem[r].hh.rh;
IF mem[r].hh.b0=1 THEN
wait:=true
ELSE
BEGIN
wait:=false;
s:=mem[p+2].int;
IF mem[r+2].hh.rh=0 THEN
mem[eqtb[2637+(mem[p].hh.b1-0)].hh.rh+5].hh.rh
:=s
ELSE
mem[mem[r+2].hh.rh].hh.rh:=s;
IF mem[r+2].hh.lh=p THEN
BEGIN
IF(mem[r].hh.b0=2)AND(mem[r+1].int<>0)
THEN
BEGIN
WHILE mem[s].hh.rh<>mem[r+1].int DO s:=mem[s].hh.rh;
mem[p+2].int:=Prunepagetop(mem[r+1].int);
mem[s].hh.rh:=0;
wait:=(mem[p+2].int<>0);
END;
mem[r].hh.b0:=1;
END;
WHILE mem[s].hh.rh<>0 DO s:=mem[s].hh.rh;
mem[r+2].hh.rh:=s;
END;
{894}mem[prevp].hh.rh:=mem[p].hh.rh;
mem[p].hh.rh:=0;
IF wait THEN
BEGIN
mem[q].hh.rh:=p;
q:=p;
END
ELSE
Flushnodelis(p);
p:=prevp;
END
ELSE
IF mem[p].hh.b0=4 THEN
{889}
BEGIN
IF curmark[1]=0 THEN
BEGIN
curmark[1]:=mem[p+1].int;
mem[curmark[1]].hh.lh:=mem[curmark[1]].hh.lh+1;
END;
IF curmark[2]<>0 THEN
Deletetokenr(curmark[2]);
curmark[2]:=mem[p+1].int;
mem[curmark[2]].hh.lh:=mem[curmark[2]].hh.lh+1;
END;
prevp:=p;
p:=mem[prevp].hh.rh;
END;
{890}
IF p=0 THEN
mem[q].hh.rh:=mem[12001].hh.rh
ELSE
BEGIN
mem[q].hh.rh
:=p;
mem[pagetail].hh.rh:=mem[12001].hh.rh;
mem[prevp].hh.rh:=0;
END;
mem[12001].hh.rh:=mem[12003].hh.rh;
eqtb[2892].hh.rh:=Vpackage(mem[12002].hh.rh,pagesize,0,pagedepthmax);
{869}emptypage:=true;
pagetail:=12002;
lastpageglue:=65535;
inspenalties:=0;
{892}r:=mem[12000].hh.rh;
WHILE r<>12000 DO
BEGIN
IF mem[r+2].hh.lh<>0 THEN
BEGIN
n:=(mem[r].hh.b1
-0);
p:=mem[eqtb[2637+n].hh.rh+5].hh.rh;
Freenode(eqtb[2637+n].hh.rh,7);
eqtb[2637+n].hh.rh:=Vpackage(p,0,1,134217727);
END;
q:=mem[r].hh.rh;
Freenode(r,3);
r:=q;
END;
IF(curmark[0]<>0)AND(curmark[1]=0)THEN
BEGIN
curmark[1]:=curmark[0];
mem[curmark[0]].hh.lh:=mem[curmark[0]].hh.lh+1;
END;
IF eqtb[2635].hh.rh<>0 THEN
{895}outputactive:=true;
Pushnest;
curlist.modefield:=-1;
curlist.auxfield:=-65536000;
curlist.mlfield:=-line;
Begintokenli(eqtb[2635].hh.rh,5);
Newsavelevel(10);
Scanleftbrac;
GOTO 10;
Shipout(eqtb[2892].hh.rh);
eqtb[2892].hh.rh:=0;
GOTO 30;
END;
END;
IF mem[p].hh.b0<>9 THEN
GOTO 80;
90:{879}
q:=mem[p+1].hh.lh;
pagesofar[1]:=pagesofar[1]+curpagedepth+mem[q+1].int;
curpagedepth:=0;
pagesofar[2+mem[q].hh.b0]:=pagesofar[2+mem[q].hh.b0]+mem[q+2].int;
pagesofar[6]:=pagesofar[6]+mem[q+3].int;
IF mem[q].hh.b1<>0 THEN
BEGIN
Printnl(680);
BEGIN
helpptr:=4;
helpline[3]:=681;
helpline[2]:=674;
helpline[1]:=675;
helpline[0]:=651;
END;
Error;
r:=Newspec(q);
mem[r].hh.b1:=0;
Deletegluere(q);
mem[p+1].hh.lh:=r;
END;
80:{874}
mem[pagetail].hh.rh:=p;
pagetail:=p;
mem[12001].hh.rh:=mem[p].hh.rh;
mem[p].hh.rh:=0;
GOTO 30;
31:{875}
mem[12001].hh.rh:=mem[p].hh.rh;
mem[p].hh.rh:=0;
Flushnodelis(p);
30:;
UNTIL mem[12001].hh.rh=0;
{871}
IF nestptr=0 THEN
curlist.tailfield:=12001
ELSE
nest[0].tailfield:=
12001;
;
10:
END;
{899}{902}PROCEDURE Missingfont;
BEGIN
printnl(692);
BEGIN
helpptr:=4;
helpline[3]:=693;
helpline[2]:=694;
helpline[1]:=695;
helpline[0]:=696;
END;
error;
END;
{912}
PROCEDURE Appspace;
VAR
p:halfword;
q:halfword;
f:internalfont;
k:0..fontmemsize;
BEGIN
IF(curlist.auxfield>=2000)AND(eqtb[2373].hh.rh<>0)THEN
q:=
newparamglue(12)
ELSE
BEGIN
IF eqtb[2372].hh.rh<>0 THEN
p:=eqtb[2372].hh.
rh
ELSE
{911}
BEGIN
p:=fontglue[eqtb[2893].hh.rh];
IF p=0 THEN
BEGIN
f:=eqtb[2893].hh.rh;
p:=newspec(0);
k:=parambase[f]+2;
mem[p+1].int:=fontinfo[k].int;
mem[p+2].int:=fontinfo[k+1].int;
mem[p+3].int:=fontinfo[k+2].int;
fontglue[f]:=p;
END;
END;
p:=newspec(p);
{913}
IF curlist.auxfield>=2000 THEN
mem[p+1].int:=
mem[p+1].int+fontinfo[7+parambase[eqtb[2893].hh.rh]].int;
mem[p+2].int:=xnoverd(mem[p+2].int,curlist.auxfield,1000);
mem[p+3].int:=xnoverd(mem[p+3].int,1000,curlist.auxfield);
q:=newglue(p);
mem[p].hh.rh:=0;
END;
mem[curlist.tailfield].hh.rh:=q;
curlist.tailfield:=q;
END;
{918}
PROCEDURE Insertdollar;
BEGIN
printnl(699);
BEGIN
helpptr:=2;
helpline[1]:=700;
helpline[0]:=701;
END;
backerror;
curcmd:=3;
curchr:=36;
curtok:=804;
END;
{920}
PROCEDURE Youcant;
BEGIN
printnl(702);
printcmdchr(curcmd,curchr);
print(703);
printmode(curlist.modefield);
END;
{921}
PROCEDURE Reportillega;
BEGIN
Youcant;
BEGIN
helpptr:=4;
helpline[3]:=704;
helpline[2]:=705;
helpline[1]:=706;
helpline[0]:=707;
END;
error;
END;
{922}
FUNCTION Privileged:boolean;
BEGIN
IF curlist.modefield>0 THEN
Privileged:=true
ELSE
BEGIN
Reportillega;
Privileged:=false;
END;
END;
{929}
PROCEDURE Appendglue;
VAR
s:smallnumber;
BEGIN
s:=curchr;
CASE s OF
0:curval:=4;
1:curval:=8;
2:curval:=12;
3:curval:=16;
4:scanglue(false);
5:scanglue(true);
END;
BEGIN
mem[curlist.tailfield].hh.rh:=newglue(curval);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
IF s>=4 THEN
BEGIN
mem[curval].hh.rh:=mem[curval].hh.rh-1;
IF s>4 THEN
mem[curlist.tailfield].hh.b1:=98;
END;
END;
{930}
PROCEDURE Appendkern;
VAR
s:quarterword;
BEGIN
s:=curchr;
scandimen(s=98,false,false);
BEGIN
mem[curlist.tailfield].hh.rh:=newkern(curval);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b1:=s;
END;
{933}
PROCEDURE Offsave;
VAR
p:halfword;
BEGIN
IF curgroup=0 THEN
{936}
BEGIN
printnl(726);
printcmdchr(curcmd,curchr);
BEGIN
helpptr:=1;
helpline[0]:=727;
END;
error;
END
ELSE
BEGIN
backinput;
p:=getavail;
mem[12003].hh.rh:=p;
printnl(718);
{935}
CASE curgroup OF
15:BEGIN
mem[p].hh.lh:=6453;
printesc(335);
END;
16:BEGIN
mem[p].hh.lh:=804;
printchar(36);
END;
17:BEGIN
mem[p].hh.lh:=6454;
mem[p].hh.rh:=getavail;
p:=mem[p].hh.rh;
mem[p].hh.lh:=3118;
printesc(725);
END;
OTHERS:BEGIN
mem[p].hh.lh:=637;
printchar(125);
END
END;
print(719);
begintokenli(mem[12003].hh.rh,3);
BEGIN
helpptr:=5;
helpline[4]:=720;
helpline[3]:=721;
helpline[2]:=722;
helpline[1]:=723;
helpline[0]:=724;
END;
error;
END;
END;
{939}
PROCEDURE Extrarightbr;
BEGIN
printnl(732);
CASE curgroup OF
15:printesc(335);
16:printchar(36);
17:printesc(608);
END;
BEGIN
helpptr:=5;
helpline[4]:=733;
helpline[3]:=734;
helpline[2]:=735;
helpline[1]:=736;
helpline[0]:=737;
END;
error;
alignstate:=alignstate+1;
END;
{945}
PROCEDURE Boxend;
VAR
p:halfword;
BEGIN
IF savestack[saveptr+0].int<0 THEN
{946}
BEGIN
IF curbox<>0 THEN
BEGIN
mem[curbox+4].int:=savestack[saveptr+0].int;
IF Abs(curlist.modefield)=1 THEN
BEGIN
appendtovlis(curbox);
IF curlist.modefield>0 THEN
buildpage;
END
ELSE
BEGIN
IF Abs(curlist.modefield)=185 THEN
BEGIN
p:=newnoad;
mem[p+1].hh.rh:=2;
mem[p+1].hh.lh:=curbox;
curbox:=p;
END;
mem[curlist.tailfield].hh.rh:=curbox;
curlist.tailfield:=curbox;
END;
END;
END
ELSE
IF savestack[saveptr+0].int<1073742336 THEN
{947}
IF savestack[saveptr+0].int<1073742080 THEN
eqdefine(-1073739187+savestack[saveptr+0].int,100,curbox)
ELSE
geqdefine(-1073739443+savestack[saveptr+0].int,100,curbox)
ELSE
IF curbox<>0 THEN
IF savestack[saveptr+0].int>1073742336
THEN
{948}
BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF((curcmd=26)AND(Abs(curlist.modefield)<>1))
OR((curcmd=27)AND(Abs(curlist.modefield)=1))THEN
BEGIN
Appendglue;
mem[curlist.tailfield].hh.b1:=savestack[saveptr+0].int-1073741211;
mem[curlist.tailfield+1].hh.rh:=curbox;
END
ELSE
BEGIN
printnl(752);
BEGIN
helpptr:=3;
helpline[2]:=753;
helpline[1]:=754;
helpline[0]:=755;
END;
error;
flushnodelis(curbox);
END;
END
ELSE
shipout(curbox);
END;
{949}
PROCEDURE Beginbox;
LABEL
10;
VAR
p:halfword;
k:halfword;
n:eightbits;
BEGIN
CASE curchr OF
0:BEGIN
scaneightbit;
curbox:=eqtb[2637+curval].hh.rh;
eqtb[2637+curval].hh.rh:=0;
END;
1:BEGIN
scaneightbit;
curbox:=copynodelist(eqtb[2637+curval].hh.rh);
END;
2:{950}BEGIN
curbox:=0;
IF(curlist.modefield=1)AND(curlist.headfield=curlist.tailfield)THEN
{951}
BEGIN
Youcant;
BEGIN
helpptr:=2;
helpline[1]:=756;
helpline[0]:=757;
END;
error;
END
ELSE
BEGIN
IF NOT(curlist.tailfield>12000)THEN
IF(mem[curlist.tailfield].hh.b0=0)
OR(mem[curlist.tailfield].hh.b0=1)THEN
BEGIN
p:=
curlist.headfield;
curbox:=curlist.tailfield;
WHILE mem[p].hh.rh<>curlist.tailfield DO p:=mem[p].hh.rh;
curlist.tailfield:=p;
mem[p].hh.rh:=0;
END;
END;
END;
3:{952}BEGIN
scaneightbit;
n:=curval;
IF NOT scankeyword(576)THEN
BEGIN
printnl(758);
BEGIN
helpptr:=2;
helpline[1]:=759;
helpline[0]:=760;
END;
error;
END;
scandimen(false,false,false);
curbox:=vsplit(n,curval);
END;
OTHERS:{953}BEGIN
k:=curchr-4;
saveptr:=saveptr+1;
scanspec;
IF k=93 THEN
newsavelevel(2)
ELSE
IF k=1 THEN
newsavelevel(3)
ELSE
BEGIN
newsavelevel(4);
k:=1;
END;
pushnest;
curlist.modefield:=-k;
IF k=1 THEN
curlist.auxfield:=-65536000
ELSE
curlist.auxfield:=1000;
END
END;
Boxend;
10:
END;
{954}
PROCEDURE Scanbox;
BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF curcmd=21 THEN
Beginbox
ELSE
IF(savestack[saveptr+0].int>=1073742337)
AND((curcmd=36)OR(curcmd=35))THEN
BEGIN
curbox:=scanrulespec;
Boxend;
END
ELSE
BEGIN
printnl(761);
BEGIN
helpptr:=3;
helpline[2]:=762;
helpline[1]:=763;
helpline[0]:=764;
END;
backerror;
END;
END;
{956}PROCEDURE Package(c:smallnumber);
VAR
h:scaled;
f:internalfont;
p:halfword;
BEGIN
unsave;
saveptr:=saveptr-3;
IF curlist.modefield=-93 THEN
curbox:=hpack(mem[curlist.headfield].hh.rh
,savestack[saveptr+2].int,savestack[saveptr+1].int)
ELSE
BEGIN
curbox:=
vpackage(mem[curlist.headfield].hh.rh,savestack[saveptr+2].int,
savestack[saveptr+1].int,134217727);
IF c=4 THEN
{957}
BEGIN
h:=0;
p:=mem[curbox+5].hh.rh;
IF p<>0 THEN
IF(mem[p].hh.b0=0)OR(mem[p].hh.b0=1)OR(mem[p].hh.b0=2)THEN
h:=mem[p+3].int;
mem[curbox+2].int:=mem[curbox+2].int-h+mem[curbox+3].int;
mem[curbox+3].int:=h;
END;
END;
popnest;
Boxend;
END;
{962}
PROCEDURE Newgraf(indented:boolean);
BEGIN
IF(curlist.modefield=1)OR(curlist.headfield<>curlist.tailfield)
THEN
BEGIN
mem[curlist.tailfield].hh.rh:=newparamglue(2);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
pushnest;
curlist.modefield:=93;
curlist.auxfield:=1000;
IF indented THEN
BEGIN
curlist.tailfield:=newnullbox;
mem[curlist.headfield].hh.rh:=curlist.tailfield;
mem[curlist.tailfield+1].int:=eqtb[4004].int;
END;
IF eqtb[2636].hh.rh<>0 THEN
BEGIN
IF curcmd<>41 THEN
backinput;
curcmd:=0;
begintokenli(eqtb[2636].hh.rh,6);
END;
IF nestptr=1 THEN
buildpage;
END;
{964}
PROCEDURE Indentinhmod;
BEGIN
IF curchr>0 THEN
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=
newnullbox;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield+1].int:=eqtb[4004].int;
END;
END;
{966}
PROCEDURE Endgraf;
BEGIN
IF curlist.modefield=93 THEN
BEGIN
IF curlist.headfield=curlist.
tailfield THEN
popnest
ELSE
linebreak(eqtb[3588].int);
IF eqtb[3602].int<>0 THEN
eqworddefine(3602,0);
IF eqtb[4021].int<>0 THEN
eqworddefine(4021,0);
IF eqtb[2634].hh.rh<>0 THEN
eqdefine(2634,99,0);
errorcount:=0;
END;
END;
{969}
PROCEDURE Begininserto;
BEGIN
IF curlist.modefield<-1 THEN
Reportillega
ELSE
BEGIN
IF curcmd=38
THEN
curval:=255
ELSE
BEGIN
scaneightbit;
IF curval=255 THEN
BEGIN
printnl(767);
BEGIN
helpptr:=1;
helpline[0]:=768;
END;
error;
curval:=0;
END;
END;
savestack[saveptr+0].int:=curval;
saveptr:=saveptr+1;
newsavelevel(13);
scanleftbrac;
pushnest;
curlist.modefield:=-1;
curlist.auxfield:=-65536000;
END;
END;
{971}
PROCEDURE Makemark;
VAR
p:halfword;
BEGIN
IF curlist.modefield<-1 THEN
Reportillega
ELSE
BEGIN
p:=scantoks(
false,true);
p:=getnode(2);
mem[p].hh.b0:=4;
mem[p].hh.b1:=0;
mem[p+1].int:=curval;
mem[curlist.tailfield].hh.rh:=p;
curlist.tailfield:=p;
END;
END;
{973}
PROCEDURE Changeaux;
BEGIN
IF curchr<>Abs(curlist.modefield)THEN
Reportillega
ELSE
IF curchr=
1 THEN
BEGIN
scandimen(false,false,false);
curlist.auxfield:=curval;
END
ELSE
BEGIN
scanint;
IF(curval<0)OR(curval>65536)THEN
BEGIN
printnl(769);
BEGIN
helpptr:=1;
helpline[0]:=770;
END;
interror(curval);
END
ELSE
curlist.auxfield:=curval;
END;
END;
{975}
PROCEDURE Appendpenalt;
BEGIN
scanint;
BEGIN
mem[curlist.tailfield].hh.rh:=newpenalty(curval);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
IF curlist.modefield=1 THEN
buildpage;
END;
{977}
PROCEDURE Deleteskip;
VAR
p:halfword;
BEGIN
IF(curlist.modefield=1)AND(curlist.tailfield=curlist.headfield)
THEN
{978}
BEGIN
Youcant;
BEGIN
helpptr:=2;
helpline[1]:=756;
helpline[0]:=771;
END;
error;
END
ELSE
BEGIN
IF NOT(curlist.tailfield>12000)THEN
IF mem[curlist.tailfield].hh.b0=9 THEN
BEGIN
p:=curlist.headfield;
WHILE mem[p].hh.rh<>curlist.tailfield DO p:=mem[p].hh.rh;
mem[p].hh.rh:=0;
flushnodelis(curlist.tailfield);
curlist.tailfield:=p;
END;
END;
END;
{980}
PROCEDURE Unpackage;
VAR
p:halfword;
BEGIN
scaneightbit;
p:=eqtb[2637+curval].hh.rh;
IF p<>0 THEN
IF((Abs(curlist.modefield)=1)AND(mem[p].hh.b0=1))
OR((Abs(curlist.modefield)=93)AND(mem[p].hh.b0=0))THEN
BEGIN
mem[curlist.
tailfield].hh.rh:=mem[p+5].hh.rh;
eqtb[2637+curval].hh.rh:=0;
freenode(p,7);
WHILE mem[curlist.tailfield].hh.rh<>0 DO curlist.tailfield:=
mem[curlist.tailfield].hh.rh;
END
ELSE
BEGIN
printnl(772);
BEGIN
helpptr:=2;
helpline[1]:=773;
helpline[0]:=774;
END;
error;
END;
END;
{983}
PROCEDURE Appenditalic;
VAR
f:internalfont;
BEGIN
IF(curlist.tailfield>12000)
AND(curlist.tailfield<>curlist.headfield)THEN
BEGIN
f:=mem[curlist.tailfield].hh.b0;
BEGIN
mem[curlist.tailfield].hh.rh:=
newkern(fontinfo[italicbase[f]+(fontinfo[charbase[f]+
mem[curlist.tailfield].hh.b1].qqqq.b2-0)DIV 4].int);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
END;
END;
{987}
PROCEDURE Appenddiscre;
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=newdisc;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
IF curchr=1 THEN
mem[curlist.tailfield+1].hh.lh:=newcharacter(eqtb[2893].hh.rh,45)
ELSE
BEGIN
saveptr:=saveptr+1;
savestack[saveptr-1].int:=0;
scanleftbrac;
newsavelevel(12);
pushnest;
curlist.modefield:=-93;
END;
END;
{989}
PROCEDURE Builddiscret;
LABEL
30,10;
VAR
p,q:halfword;
n:integer;
BEGIN
unsave;
{991}q:=curlist.headfield;
p:=mem[q].hh.rh;
n:=0;
WHILE p<>0 DO
BEGIN
IF NOT(p>12000)THEN
IF(mem[p].hh.b0<>10)AND(mem[p].hh.b0<>6)THEN
BEGIN
printnl(778);
begindiagnos;
showbox(p);
enddiagnosti;
BEGIN
helpptr:=1;
helpline[0]:=779;
END;
error;
flushnodelis(p);
mem[q].hh.rh:=0;
GOTO 30;
END;
q:=p;
p:=mem[q].hh.rh;
n:=n+1;
END;
30:;
p:=mem[curlist.headfield].hh.rh;
popnest;
CASE savestack[saveptr-1].int OF
0:mem[curlist.tailfield+1].hh.lh:=p;
1:mem[curlist.tailfield+1].hh.rh:=p;
2:{990}BEGIN
mem[curlist.tailfield].hh.rh:=p;
IF n<128 THEN
mem[curlist.tailfield].hh.b1:=n
ELSE
BEGIN
printnl(775);
BEGIN
helpptr:=2;
helpline[1]:=776;
helpline[0]:=777;
END;
error;
END;
curlist.tailfield:=q;
saveptr:=saveptr-1;
GOTO 10;
END;
END;
savestack[saveptr-1].int:=savestack[saveptr-1].int+1;
scanleftbrac;
newsavelevel(12);
pushnest;
curlist.modefield:=-93;
10:
END;
{993}
PROCEDURE Insthe;
BEGIN
printnl(780);
BEGIN
helpptr:=3;
helpline[2]:=781;
helpline[1]:=782;
helpline[0]:=783;
END;
backerror;
mem[12013].hh.rh:=thetoks(false);
begintokenli(curval,3);
END;
{996}
PROCEDURE Makeaccent;
VAR
s,t:real;
p,q:halfword;
f:internalfont;
a,h,x,w,delta:scaled;
i:fourquarters;
BEGIN
scancharnum;
f:=eqtb[2893].hh.rh;
p:=newcharacter(f,curval);
IF p<>0 THEN
BEGIN
x:=fontinfo[5+parambase[f]].int;
s:=fontinfo[1+parambase[f]].int/65536.0;
a:=fontinfo[widthbase[f]+fontinfo[charbase[f]+mem[p].hh.b1].qqqq.b0].int;
doassignment;
{997}q:=0;
f:=eqtb[2893].hh.rh;
IF(curcmd=11)OR(curcmd=12)THEN
q:=newcharacter(f,curchr)
ELSE
IF curcmd=16 THEN
BEGIN
scancharnum;
q:=newcharacter(f,curval);
END
ELSE
backinput;
IF q<>0 THEN
{998}
BEGIN
t:=fontinfo[1+parambase[f]].int/65536.0;
i:=fontinfo[charbase[f]+mem[q].hh.b1].qqqq;
w:=fontinfo[widthbase[f]+i.b0].int;
h:=fontinfo[heightbase[f]+(i.b1-0)DIV 16].int;
IF h<>x THEN
BEGIN
p:=hpack(p,0,1);
mem[p+4].int:=x-h;
END;
delta:=Round((w-a)/2+h*t-x*s);
mem[curlist.tailfield].hh.rh:=newkern(delta);
mem[mem[curlist.tailfield].hh.rh].hh.rh:=p;
mem[p].hh.rh:=newkern(-a-delta);
curlist.tailfield:=mem[p].hh.rh;
p:=q;
END;
mem[curlist.tailfield].hh.rh:=p;
curlist.tailfield:=p;
END;
END;
{1000}
PROCEDURE Alignerror;
BEGIN
IF Abs(alignstate)>2 THEN
{1001}
BEGIN
printnl(788);
BEGIN
helpptr:=5;
helpline[4]:=789;
helpline[3]:=790;
helpline[2]:=791;
helpline[1]:=792;
helpline[0]:=793;
END;
error;
curcmd:=0;
END
ELSE
BEGIN
backinput;
IF alignstate<0 THEN
BEGIN
printnl(436);
curcmd:=1;
alignstate:=alignstate+1;
curtok:=379;
END
ELSE
BEGIN
printnl(784);
curcmd:=2;
alignstate:=alignstate-1;
curtok:=637;
END;
BEGIN
helpptr:=3;
helpline[2]:=785;
helpline[1]:=786;
helpline[0]:=787;
END;
error;
END;
END;
{1002}
PROCEDURE Noalignerror;
BEGIN
printnl(794);
BEGIN
helpptr:=2;
helpline[1]:=795;
helpline[0]:=796;
END;
error;
END;
PROCEDURE Omiterror;
BEGIN
printnl(797);
BEGIN
helpptr:=2;
helpline[1]:=798;
helpline[0]:=796;
END;
error;
END;
{1005}PROCEDURE Doendv;
BEGIN
IF curgroup=8 THEN
BEGIN
Endgraf;
unsave;
newsavelevel(8);
IF fincol THEN
finrow;
END
ELSE
Offsave;
END;
{1008}
PROCEDURE Initmath;
LABEL
21,40,45,30,10;
VAR
w:scaled;
l:scaled;
s:scaled;
p:halfword;
q:halfword;
f:internalfont;
n:integer;
v:scaled;
d:scaled;
BEGIN{1010}
IF(fontparams[eqtb[2896].hh.rh]<22)
OR(fontparams[eqtb[2912].hh.rh]<22)
OR(fontparams[eqtb[2928].hh.rh]<22)
OR(fontparams[eqtb[2897].hh.rh]<13)THEN
BEGIN
printnl(799);
BEGIN
helpptr:=4;
helpline[3]:=800;
helpline[2]:=801;
helpline[1]:=802;
helpline[0]:=803;
END;
error;
GOTO 10;
END;
getnctoken;
IF(curcmd=3)AND(curlist.modefield>0)THEN
{1016}
BEGIN
IF curlist.headfield=curlist.tailfield THEN
BEGIN
popnest;
w:=-134217727;
END
ELSE
BEGIN
linebreak(eqtb[3589].int);
{1017}v:=
mem[justbox+4].int+2*fontinfo[6+parambase[eqtb[2893].hh.rh]].int;
w:=-134217727;
p:=mem[justbox+5].hh.rh;
WHILE p<>0 DO
BEGIN{1018}
21:
IF(p>12000)THEN
BEGIN
f:=mem[p].hh.b0;
d:=fontinfo[widthbase[f]+
fontinfo[charbase[f]+mem[p].hh.b1].qqqq.b0].int;
GOTO 40;
END;
CASE mem[p].hh.b0 OF
0,1,2:BEGIN
d:=mem[p+1].int;
GOTO 40;
END;
6:{558}BEGIN
mem[12012]:=mem[p+1];
mem[12012].hh.rh:=mem[p].hh.rh;
p:=12012;
GOTO 21;
END;
10,11:d:=mem[p+1].int;
9:{1019}BEGIN
q:=mem[p+1].hh.lh;
d:=mem[q+1].int;
IF((mem[justbox+5].hh.b0=1)
AND(mem[justbox+5].hh.b1=mem[q].hh.b0))
OR((mem[justbox+5].hh.b0=2)
AND(mem[justbox+5].hh.b1=mem[q].hh.b1))
THEN
v:=134217727;
IF mem[p].hh.b1>=100 THEN
GOTO 40;
END;
8:{1218}d:=0;
OTHERS:d:=0
END;
IF v<134217727 THEN
v:=v+d;
GOTO 45;
40:
IF v<134217727 THEN
BEGIN
v:=v+d;
w:=v;
END
ELSE
BEGIN
w:=134217727;
GOTO 30;
END;
45:
p:=mem[p].hh.rh;
END;
30:;
END;
{1020}
IF eqtb[2634].hh.rh=0 THEN
IF(eqtb[4021].int<>0)
AND(((eqtb[3619].int>=0)AND(curlist.alreadyfield+2>eqtb[3619].int))
OR(curlist.alreadyfield+1<-eqtb[3619].int))THEN
BEGIN
l:=eqtb[4008].int-Abs(eqtb[4021].int);
IF eqtb[4021].int>0 THEN
s:=eqtb[4021].int
ELSE
s:=0;
END
ELSE
BEGIN
l:=eqtb[4008].int;
s:=0;
END
ELSE
BEGIN
n:=mem[eqtb[2634].hh.rh].hh.lh;
IF curlist.alreadyfield+2>=n THEN
p:=eqtb[2634].hh.rh+2*n
ELSE
p:=eqtb[2634].hh.rh+2*(curlist.alreadyfield+2);
s:=mem[p-1].int;
l:=mem[p].int;
END;
pushnest;
curlist.modefield:=185;
curlist.auxfield:=0;
newsavelevel(16);
eqdefine(2942,101,1);
eqworddefine(2374,w);
eqworddefine(2375,l);
eqworddefine(2376,s);
IF curlist.modefield=1 THEN
buildpage;
END
ELSE
BEGIN
backinput;
{1009}
BEGIN
pushnest;
curlist.modefield:=-185;
curlist.auxfield:=0;
newsavelevel(16);
eqdefine(2942,101,1);
END;
END;
10:
END;
{1013}
PROCEDURE Starteqno;
BEGIN
IF curgroup=16 THEN
BEGIN
savestack[saveptr+0].int:=curchr;
saveptr:=saveptr+1;
{1009}
BEGIN
pushnest;
curlist.modefield:=-185;
curlist.auxfield:=0;
newsavelevel(16);
eqdefine(2942,101,1);
END;
END
ELSE
Offsave;
END;
{1022}
PROCEDURE Scanmath(p:halfword);
LABEL
10;
VAR
c:integer;
BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
CASE curcmd OF
11,12:c:=eqtb[3071+curchr].hh.rh;
16:BEGIN
scancharnum;
c:=curval+28672;
END;
17:BEGIN
scanfifteenb;
c:=curval;
END;
15:BEGIN
scantwentyse;
c:=curval DIV 4096;
END;
OTHERS:{1023}BEGIN
backinput;
scanleftbrac;
savestack[saveptr+0].int:=p;
saveptr:=saveptr+1;
newsavelevel(11);
pushnest;
curlist.auxfield:=0;
END
END;
mem[p].hh.rh:=1;
mem[p].hh.b1:=c MOD 256;
IF c>=28672 THEN
mem[p].hh.b0:=eqtb[2942].hh.rh
ELSE
mem[p].hh.b0:=(cdiv 256)MOD 16;
GOTO 10;
10:
END;
{1025}
PROCEDURE Setmathchar(c:integer);
VAR
p:halfword;
BEGIN
p:=newnoad;
mem[p+1].hh.rh:=1;
mem[p+1].hh.b1:=c MOD 256;
IF c>=28672 THEN
BEGIN
mem[p+1].hh.b0:=eqtb[2942].hh.rh;
mem[p].hh.b0:=15;
END
ELSE
BEGIN
mem[p+1].hh.b0:=(c DIV 256)MOD 16;
mem[p].hh.b0:=15+(c DIV 4096);
END;
mem[curlist.tailfield].hh.rh:=p;
curlist.tailfield:=p;
END;
{1029}
PROCEDURE Mathlimitswi;
LABEL
10;
BEGIN
IF curlist.headfield<>curlist.tailfield THEN
IF mem[curlist.tailfield].hh.b0=16 THEN
BEGIN
mem[curlist.tailfield].hh.b1:=1-mem[curlist.tailfield].hh.b1;
GOTO 10;
END;
printnl(806);
BEGIN
helpptr:=1;
helpline[0]:=807;
END;
10:
END;
{1030}
PROCEDURE Scandelimite(p:halfword;
r:boolean);
BEGIN
IF r THEN
scantwentyse
ELSE
BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
CASE curcmd OF
11,12:curval:=eqtb[3876+curchr].int;
15:scantwentyse;
OTHERS:curval:=-1
END;
END;
IF curval<0 THEN
{1031}
BEGIN
printnl(808);
BEGIN
helpptr:=6;
helpline[5]:=809;
helpline[4]:=810;
helpline[3]:=811;
helpline[2]:=812;
helpline[1]:=813;
helpline[0]:=814;
END;
backerror;
curval:=0;
END;
mem[p].qqqq.b0:=(curval DIV 1048576)MOD 16;
mem[p].qqqq.b1:=(curval DIV 4096)MOD 256;
mem[p].qqqq.b2:=(curval DIV 256)MOD 16;
mem[p].qqqq.b3:=curval MOD 256;
END;
{1033}
PROCEDURE Mathradical;
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=getnode(5);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b0:=23;
mem[curlist.tailfield].hh.b1:=0;
mem[curlist.tailfield+1].hh:=emptyfield;
mem[curlist.tailfield+3].hh:=emptyfield;
mem[curlist.tailfield+2].hh:=emptyfield;
Scandelimite(curlist.tailfield+4,true);
Scanmath(curlist.tailfield+1);
END;
{1035}
PROCEDURE Mathac;
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=getnode(5);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b0:=27;
mem[curlist.tailfield].hh.b1:=0;
mem[curlist.tailfield+1].hh:=emptyfield;
mem[curlist.tailfield+3].hh:=emptyfield;
mem[curlist.tailfield+2].hh:=emptyfield;
mem[curlist.tailfield+4].hh.rh:=1;
scanfifteenb;
mem[curlist.tailfield+4].hh.b1:=curval MOD 256;
IF curval>=28672 THEN
mem[curlist.tailfield+4].hh.b0:=eqtb[2942].hh.rh
ELSE
mem[curlist.tailfield+4].hh.b0:=(curval DIV 256)MOD 16;
Scanmath(curlist.tailfield+1);
END;
{1041}
PROCEDURE Mathnonscrip;
BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF(curcmd>30)OR(curcmd<26)THEN
BEGIN
printnl(815);
BEGIN
helpptr:=2;
helpline[1]:=816;
helpline[0]:=817;
END;
backerror;
END
ELSE
BEGIN
backinput;
BEGIN
mem[curlist.tailfield].hh.rh:=newglue(0);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
deletegluere(0);
mem[curlist.tailfield].hh.b1:=99;
END;
END;
{1043}
PROCEDURE Subsup;
VAR
t:smallnumber;
p:halfword;
BEGIN
t:=0;
p:=0;
IF curlist.tailfield<>curlist.headfield
THEN
IF(mem[curlist.tailfield].hh.b0>=15)
AND(mem[curlist.tailfield].hh.b0<29)THEN
BEGIN
p:=curlist.tailfield+2+curcmd-7;
t:=mem[p].hh.rh;
END;
IF(p=0)OR(t<>0)THEN
{1044}
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=newnoad;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b0:=15;
p:=curlist.tailfield+2+curcmd-7;
IF t<>0 THEN
BEGIN
IF curcmd=7 THEN
BEGIN
printnl(818);
BEGIN
helpptr:=1;
helpline[0]:=819;
END;
END
ELSE
BEGIN
printnl(820);
BEGIN
helpptr:=1;
helpline[0]:=821;
END;
END;
error;
END;
END;
Scanmath(p);
END;
{1048}
PROCEDURE Mathfraction;
VAR
c:smallnumber;
BEGIN
c:=curchr;
IF curlist.auxfield<>0 THEN
{1050}
BEGIN
IF c MOD 3=0 THEN
scandimen(false,false,false);
IF c>=3 THEN
BEGIN
Scandelimite(12013,false);
Scandelimite(12013,false);
END;
printnl(827);
BEGIN
helpptr:=3;
helpline[2]:=828;
helpline[1]:=829;
helpline[0]:=830;
END;
error;
END
ELSE
BEGIN
curlist.auxfield:=getnode(6);
mem[curlist.auxfield].hh.b0:=24;
mem[curlist.auxfield].hh.b1:=0;
mem[curlist.auxfield+2].hh.rh:=3;
mem[curlist.auxfield+2].hh.lh:=mem[curlist.headfield].hh.rh;
mem[curlist.auxfield+3].hh:=emptyfield;
mem[curlist.auxfield+4].qqqq:=nullcharacte;
mem[curlist.auxfield+5].qqqq:=nullcharacte;
mem[curlist.headfield].hh.rh:=0;
curlist.tailfield:=curlist.headfield;
{1049}
CASE c MOD 3 OF
0:BEGIN
scandimen(false,false,false);
mem[curlist.auxfield+1].int:=curval;
END;
1:mem[curlist.auxfield+1].int:=1073741824;
2:mem[curlist.auxfield+1].int:=0;
END;
IF c>=3 THEN
BEGIN
Scandelimite(curlist.auxfield+4,false);
Scandelimite(curlist.auxfield+5,false);
END;
END;
END;
{1051}
FUNCTION Finmlist(p:halfword):halfword;
VAR
q:halfword;
BEGIN
IF curlist.auxfield<>0 THEN
{1052}
BEGIN
mem[curlist.auxfield+3].hh.rh:=3;
mem[curlist.auxfield+3].hh.lh:=mem[curlist.headfield].hh.rh;
IF p=0 THEN
q:=curlist.auxfield
ELSE
BEGIN
q:=mem[curlist.auxfield+2].hh.lh;
IF mem[q].hh.b0<>29 THEN
confusion(608);
mem[curlist.auxfield+2].hh.lh:=mem[q].hh.rh;
mem[q].hh.rh:=curlist.auxfield;
mem[curlist.auxfield].hh.rh:=p;
END;
END
ELSE
BEGIN
mem[curlist.tailfield].hh.rh:=p;
q:=mem[curlist.headfield].hh.rh;
END;
popnest;
Finmlist:=q;
END;
{1057}
PROCEDURE Mathleftrigh;
VAR
t:smallnumber;
p:halfword;
BEGIN
t:=curchr;
IF(t=30)AND(curgroup<>17)THEN
{1058}
BEGIN
IF curgroup=16 THEN
BEGIN
Scandelimite(12013,false);
printnl(831);
BEGIN
helpptr:=1;
helpline[0]:=832;
END;
error;
END
ELSE
Offsave;
END
ELSE
BEGIN
p:=newnoad;
mem[p].hh.b0:=t;
Scandelimite(p+1,false);
IF t=29 THEN
BEGIN
pushnest;
newsavelevel(17);
mem[curlist.headfield].hh.rh:=p;
curlist.tailfield:=p;
END
ELSE
BEGIN
p:=Finmlist(p);
unsave;
BEGIN
mem[curlist.tailfield].hh.rh:=newnoad;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield+1].hh.rh:=3;
mem[curlist.tailfield+1].hh.lh:=p;
END;
END;
END;
{1060}
PROCEDURE Finmath;
VAR
l:boolean;
m:integer;
p:halfword;
a:halfword;
{1063}b:halfword;
w:scaled;
z:scaled;
e:scaled;
q:scaled;
d:scaled;
s:scaled;
g1,g2:smallnumber;
r:halfword;
BEGIN
m:=curlist.modefield;
l:=false;
p:=Finmlist(0);
IF curlist.modefield=-m THEN
BEGIN
a:=hpack(mlisttohlist(p,2,false),0,1);
unsave;saveptr:=saveptr-1;
IF savestack[saveptr+0].int=1 THEN
l:=true;
m:=curlist.modefield;
p:=Finmlist(0);
END
ELSE
a:=0;
IF m<0 THEN
{1061}
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=newmath(eqtb[4005].int,0);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.rh:=mlisttohlist(p,2,true);
WHILE mem[curlist.tailfield].hh.rh<>0
DO curlist.tailfield:=mem[curlist.tailfield].hh.rh;
BEGIN
mem[curlist.tailfield].hh.rh:=newmath(eqtb[4005].int,1);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
curlist.auxfield:=1000;
unsave;
END
ELSE
BEGIN{1062}
BEGIN
getnctoken;
IF curcmd<>3 THEN
BEGIN
printnl(833);
BEGIN
helpptr:=2;
helpline[1]:=834;
helpline[0]:=835;
END;
backerror;
END;
END;
{1064}p:=mlisttohlist(p,0,false);
b:=hpack(p,0,1);
w:=mem[b+1].int;
z:=eqtb[4018].int;
s:=eqtb[4019].int;
IF a=0 THEN
BEGIN
e:=0;
q:=0;
END
ELSE
BEGIN
e:=mem[a+1].int;
q:=e+fontinfo[6+parambase[eqtb[2896].hh.rh]].int;
END;
IF w+q>z THEN
{1066}
BEGIN
IF(e<>0)AND((w-totalshrink[0]+q<=z)OR(totalshrink[1]<>0)
OR(totalshrink[2]<>0)OR(totalshrink[3]<>0))THEN
BEGIN
freenode(b,7);
b:=hpack(p,z-q,0);
END
ELSE
BEGIN
e:=0;
IF w>z THEN
BEGIN
freenode(b,7);
b:=hpack(p,z,0);
END;
END;
w:=mem[b+1].int;
END;
{1067}d:=half(z-w);
IF(e>0)AND(d<2*e)THEN
BEGIN
d:=half(z-w-e);
IF p<>0 THEN
IF mem[p].hh.b0=9 THEN
d:=0;
END;
{1068}
BEGIN
mem[curlist.tailfield].hh.rh:=newpenalty(eqtb[3594].int);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
IF(d+s<=eqtb[4017].int)OR l THEN
BEGIN
g1:=3;
g2:=3;
END
ELSE
BEGIN
g1:=4;
g2:=5;
END;
IF l AND(e=0)THEN
BEGIN
mem[a+4].int:=s;
appendtovlis(a);
BEGIN
mem[curlist.tailfield].hh.rh:=newpenalty(10000);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
END
ELSE
BEGIN
mem[curlist.tailfield].hh.rh:=newparamglue(g1);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
{1069}
IF e<>0 THEN
BEGIN
p:=newkern(z-w-e-d);
IF l THEN
BEGIN
mem[a].hh.rh:=r;
mem[r].hh.rh:=b;
b:=a;
d:=0;
END
ELSE
BEGIN
mem[b].hh.rh:=r;
mem[r].hh.rh:=a;
END;
END;
mem[b+4].int:=s+d;
appendtovlis(b);
{1070}
IF(a<>0)AND(e=0)AND NOT l THEN
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=newpenalty(10000);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[a+4].int:=s+z-mem[a+1].int;
appendtovlis(a);
BEGIN
mem[curlist.tailfield].hh.rh:=newpenalty(eqtb[3593].int);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
END
ELSE
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=newpenalty(eqtb[3593].int);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
BEGIN
mem[curlist.tailfield].hh.rh:=newparamglue(g2);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
END;
resumeafterd;
END;
END;
{1065}PROCEDURE Resumeafterd;
BEGIN
IF curgroup<>16 THEN
confusion(836);
unsave;
curlist.alreadyfield:=curlist.alreadyfield+3;
pushnest;
curlist.modefield:=93;
curlist.auxfield:=1000;
{365}
BEGIN
getnctoken;
IF curcmd<>10 THEN
backinput;
END;
IF nestptr=1 THEN
buildpage;
END;
{1076}
PROCEDURE Conditional;
LABEL
10;
VAR
b:boolean;
r:60..62;
n:integer;
c:1..2;
p,q:halfword;
BEGIN
CASE curchr OF
0:{1080}BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF(curtok>=3328)OR(curcmd=9)THEN
n:=256
ELSE
BEGIN
n:=curchr;
{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF(curtok>=3328)OR(curcmd=9)THEN
n:=256;
END;
IF n<256 THEN
b:=(n=curchr)
ELSE
BEGIN
printnl(851);
BEGIN
helpptr:=2;
helpline[1]:=852;
helpline[0]:=853;
END;
backerror;
GOTO 10;
END;
END;
1,2:{1077}BEGIN
c:=curchr;
IF c=1 THEN
scanint
ELSE
scandimen(false,false,false);
n:=curval;
{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF(curtok>=3132)AND(curtok<=3134)THEN
r:=curtok-3072
ELSE
BEGIN
printnl(849);
printcmdchr(55,c);
BEGIN
helpptr:=1;
helpline[0]:=850;
END;
backerror;
r:=61;
END;
IF c=1 THEN
scanint
ELSE
scandimen(false,false,false);
CASE r OF
60:b:=(n<curval);
61:b:=(n=curval);
62:b:=(n>curval);
END;
END;
3:{1078}BEGIN
scaneightbit;
b:=NOT Odd(eqtb[3620+curval].int);
END;
4:b:=(Abs(curlist.modefield)=1);
5:b:=(Abs(curlist.modefield)=93);
6:b:=(Abs(curlist.modefield)=185);
7:b:=(curlist.modefield<0);
8:{1079}BEGIN
scaneightbit;
b:=(eqtb[2637+curval].hh.rh=0);
END;
9:{1081}BEGIN
gettoken;
n:=csptr;
IF n<>0 THEN
gettoken;
IF csptr<>0 THEN
BEGIN
IF curcmd<>eqtb[n].hh.b0 THEN
b:=false
ELSE
IF curcmd<94 THEN
b:=(curchr=eqtb[n].hh.rh)
ELSE
{1082}
BEGIN
p:=mem[curcmd].hh.rh;
q:=mem[eqtb[n].hh.rh].hh.rh;
WHILE(p<>0)AND(q<>0)DO
IF mem[p].hh.lh<>mem[q].hh.lh THEN
p:=0
ELSE
BEGIN
p:=mem[p].hh.rh;
q:=mem[q].hh.rh;
END;
b:=((p=0)AND(q=0));
END;
END
ELSE
BEGIN
printnl(854);
BEGIN
helpptr:=2;
helpline[1]:=855;
helpline[0]:=853;
END;
backerror;
GOTO 10;
END;
END;
END;
{1083}
IF b THEN
BEGIN
scanleftbrac;
newsavelevel(5);
curlevel:=curlevel-1;
END
ELSE
BEGIN
passblock(0);
{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF curcmd=57 THEN
BEGIN
scanleftbrac;
newsavelevel(6);
curlevel:=curlevel-1;
END
ELSE
BEGIN
printnl(856);
BEGIN
helpptr:=3;
helpline[2]:=857;
helpline[1]:=858;
helpline[0]:=859;
END;
backerror;
END;
END;
10:
END;
{1086}
PROCEDURE Spuriouselse;
BEGIN
printnl(861);
BEGIN
helpptr:=2;
helpline[1]:=862;
helpline[0]:=863;
END;
error;
END;
{1087}
PROCEDURE Caseconditio;
LABEL
10,30;
VAR
n:integer;
BEGIN
scanint;
n:=curval;
WHILE n<>0 DO
BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF curcmd<>1 THEN
IF curcmd=57 THEN
GOTO 30
ELSE
{1089}
BEGIN
printnl(864);
BEGIN
helpptr:=3;
helpline[2]:=865;
helpline[1]:=866;
helpline[0]:=859;
END;
backerror;
GOTO 10;
END;
passblock(1);
n:=n-1;
END;
30:
scanleftbrac;
IF n=0 THEN
newsavelevel(7)
ELSE
newsavelevel(6);
curlevel:=curlevel-1;
10:
END;
{1093}{1125}
PROCEDURE Newfont;
LABEL
21,10;
VAR
u:0..badfontcode;
s:scaled;
n:strnumber;
f:internalfont;
BEGIN
scanfontnumb;
u:=curval;
scanoptional;
21:
scanfilename;
{1126}
IF scankeyword(928)THEN
BEGIN
scandimen(false,false,false);
s:=curval;
IF(s<=0)OR(s>=134217728)THEN
BEGIN
printnl(929);
BEGIN
helpptr:=2;
helpline[1]:=930;
helpline[0]:=931;
END;
error;
s:=10*65536;
END;
END
ELSE
s:=0;
IF u=badfontcode THEN
GOTO 10;
{1127}
IF fontnumber[u]<>0 THEN
BEGIN
f:=fontnumber[u];
IF((s=0)AND fontscaled[f])OR((s<>0)AND(s<>fontsize[f]))
OR NOT streqstr(fontname[f],curname)
OR NOT streqstr(fontarea[f],curarea)THEN
{1128}
BEGIN
printnl(543);
printint(u);
print(932);
print(fontname[f]);
IF fontscaled[f]THEN
BEGIN
print(544);
printscaled(fontsize[f]);
print(482);
END;
BEGIN
helpptr:=2;
helpline[1]:=933;
helpline[0]:=934;
END;
error;
END;
GOTO 10;
END;
{1129}
FOR f:=1 TO fontptr DO
IF streqstr(fontname[f],curname)AND
streqstr(fontarea[f],curarea)AND((s=0)
AND NOT fontscaled[f])OR((s<>0)AND(s=fontsize[f]))THEN
BEGIN
fontnumber[u]:=f;
fontcode[f]:=u;
GOTO 10;
END;
;
readfontinfo(u,curname,curarea,s);
10:
END;
{1133}
PROCEDURE Newinteracti;
BEGIN
println;
interaction:=curchr;
{71}
IF interaction=0 THEN
selector:=16
ELSE
selector:=17;
IF jobname<>0 THEN
selector:=selector+2;
END;
PROCEDURE Prefixedcomm;
LABEL
10;
VAR
a:smallnumber;
j:halfword;
k:0..fontmemsize;
p,q,r:halfword;
n:integer;
e:boolean;
BEGIN
a:=0;
WHILE curcmd=80 DO
BEGIN
IF NOT Odd(a DIV curchr)THEN
a:=a+curchr;
{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF curcmd<80 THEN
{1094}
BEGIN
printnl(875);
printcmdchr(curcmd,curchr);
printchar(39);
BEGIN
helpptr:=1;
helpline[0]:=876;
END;
backerror;
GOTO 10;
END;
END;
{1095}
IF(curcmd<>82)AND(a MOD 4<>0)THEN
BEGIN
printnl(877);
printcmdchr(curcmd,curchr);
printchar(39);
BEGIN
helpptr:=1;
helpline[0]:=878;
END;
error;
END;
CASE curcmd OF
{1097}78:BEGIN
scanfontnumb;
IF(a>=4)THEN
geqdefine(2893,101,curval)
ELSE
eqdefine(2893,101,curval);
END;
79:BEGIN
scanfourbiti;
IF(a>=4)THEN
geqdefine(2942,101,curval)
ELSE
eqdefine(2942,101,curval);
END;
{1098}82:BEGIN
IF Odd(curchr)AND NOT(a>=4)THEN
a:=a+4;
e:=(curchr>=2);
gettoken;
IF curtok<4096 THEN
{1099}
BEGIN
printnl(879);
BEGIN
helpptr:=4;
helpline[3]:=880;
helpline[2]:=881;
helpline[1]:=882;
helpline[0]:=883;
END;
backerror;
END
ELSE
BEGIN
p:=csptr;
q:=scantoks(true,e);
IF(a>=4)THEN
geqdefine(p,94+(a MOD 4),curval)
ELSE
eqdefine(p,94+(a MOD 4
),curval);
END;
END;
{1100}81:BEGIN
e:=true;
{1101}gettoken;
IF csptr<>0 THEN
BEGIN
p:=csptr;
REPEAT
gettoken;
UNTIL(curcmd<>10)AND(curtok<>3133);
IF curtok>=4096 THEN
BEGIN
e:=false;
IF curcmd>=94 THEN
mem[curchr].hh.lh:=mem[curchr].hh.lh+1;
IF(a>=4)THEN
geqdefine(p,curcmd,curchr)
ELSE
eqdefine(p,curcmd,curchr);
END;
END;
IF e THEN
BEGIN
printnl(884);
BEGIN
helpptr:=2;
helpline[1]:=885;
helpline[0]:=886;
END;
backerror;
END;
END;
{1102}70:BEGIN
p:=curchr;
scanoptional;
q:=scantoks(false,false);
IF mem[curval].hh.rh=0 THEN
IF(a>=4)THEN
geqdefine(p,92,0)
ELSE
eqdefine(p,92,0)
ELSE
BEGIN
IF p=2635 THEN
BEGIN
mem[q].hh.rh:=getavail;
q:=mem[q].hh.rh;
mem[q].hh.lh:=637;
q:=getavail;
mem[q].hh.lh:=379;
mem[q].hh.rh:=mem[curval].hh.rh;
mem[curval].hh.rh:=q;
END;
IF(a>=4)THEN
geqdefine(p,94,curval)
ELSE
eqdefine(p,94,curval);
END;
END;
{1103}71:BEGIN
p:=curchr;
scanoptional;
scanint;
IF(a>=4)THEN
geqworddefin(3583+p,curval)
ELSE
eqworddefine(3583+p,curval);
END;
72:BEGIN
p:=curchr;
scanoptional;
scandimen(false,false,false);
IF(a>=4)THEN
geqworddefin(4004+p,curval)
ELSE
eqworddefine(4004+p,curval)
;
END;
73:BEGIN
p:=curchr;
scanoptional;
scanglue(p>=14);
IF(mem[curval+1].int=0)AND(mem[curval+2].int=0)AND(mem[curval+3].int=0)
THEN
BEGIN
mem[0].hh.rh:=mem[0].hh.rh+1;
deletegluere(curval);
curval:=0;
END;
IF(a>=4)THEN
geqdefine(2361+p,98,curval)
ELSE
eqdefine(2361+p,98,curval);
END;
{1104}75:BEGIN
scanoptional;
scandimen(false,false,false);
IF(a>=4)THEN
geqworddefin(4021,curval)
ELSE
eqworddefine(4021,curval);
n:=1;
IF scankeyword(887)THEN
BEGIN
scanint;
n:=curval;
END
ELSE
IF scankeyword(888)THEN
BEGIN
scanint;
n:=-curval;
IF n=0 THEN
eqtb[4021].int:=0;
END
ELSE
n:=1;
IF(a>=4)THEN
geqworddefin(3619,n)
ELSE
eqworddefine(3619,n);
END;
{1107}76:BEGIN{1108}
IF curchr=2943 THEN
n:=15
ELSE
IF curchr=3071 THEN
n
:=32767
ELSE
IF curchr=3455 THEN
n:=65536
ELSE
IF curchr=3876 THEN
n:=
16777215
ELSE
n:=127;
p:=curchr;
scansevenbit;
p:=p+curval;
scanoptional;
scanint;
IF((curval<0)AND(p<3876))OR(curval>n)THEN
BEGIN
printnl(895);
printint(curval);
IF p<3876 THEN
print(896)
ELSE
print(897);
printint(n);
BEGIN
helpptr:=1;
helpline[0]:=898;
END;
error;
curval:=0;
END;
IF p<3876 THEN
IF(a>=4)THEN
geqdefine(p,101,curval)
ELSE
eqdefine(p,101,
curval)
ELSE
IF(a>=4)THEN
geqworddefin(p,curval)
ELSE
eqworddefine(p,
curval);
END;
{1109}77:BEGIN
p:=curchr;
scanfourbiti;
p:=p+curval;
scanoptional;
scanint;
IF(curval>=badfontcode)OR(curval<0)THEN
n:=0
ELSE
n:=fontnumber[curval];
IF n=0 THEN
BEGIN
printnl(899);
printint(curval);
print(900);
BEGIN
helpptr:=1;
helpline[0]:=901;
END;
error;
END
ELSE
IF(a>=4)THEN
geqdefine(p,101,n)
ELSE
eqdefine(p,101,n);
END;
{1112}84,85,86,87:BEGIN
p:=curchr;
q:=curcmd;
scaneightbit;
n:=curval;
IF q=84 THEN
scanoptional
ELSE
{1113}
IF NOT scankeyword(921)THEN
BEGIN
printnl(922);
BEGIN
helpptr:=2;
helpline[1]:=923;
helpline[0]:=924;
END;
error;
GOTO 10;
END;
aritherror:=false;
IF q<86 THEN
{1114}
CASE p OF
0:BEGIN
scanint;
IF q=85 THEN
curval:=curval+eqtb[3620+n].int;
END;
1:BEGIN
scandimen(false,false,false);
IF q=85 THEN
curval:=curval+eqtb[4022+n].int;
END;
2:BEGIN
scanglue(false);
IF q=85 THEN
{1115}
BEGIN
q:=newspec(curval);
r:=eqtb[2378+n].hh.rh;
deletegluere(curval);
mem[q+1].int:=mem[q+1].int+mem[r+1].int;
IF mem[q+2].int=0 THEN
mem[q].hh.b0:=0;
IF mem[q].hh.b0=mem[r].hh.b0 THEN
mem[q+2].int:=mem[q+2].int+mem[r+2].
int
ELSE
IF(mem[q].hh.b0<mem[r].hh.b0)AND(mem[r+2].int<>0)THEN
BEGIN
mem
[q+2].int:=mem[r+2].int;
mem[q].hh.b0:=mem[r].hh.b0;
END;
IF mem[q+3].int=0 THEN
mem[q].hh.b1:=0;
IF mem[q].hh.b1=mem[r].hh.b1 THEN
mem[q+3].int:=mem[q+3].int+mem[r+3].
int
ELSE
IF(mem[q].hh.b1<mem[r].hh.b1)AND(mem[r+3].int<>0)THEN
BEGIN
mem
[q+3].int:=mem[r+3].int;
mem[q].hh.b1:=mem[r].hh.b1;
END;
END;
END;
END
ELSE
{1116}
BEGIN
scanint;
CASE p OF
0:IF q=86 THEN
curval:=nxplusy(eqtb[3620+n].int,curval,0)
ELSE
curval:=xovern(eqtb[3620+n].int,curval);
1:IF q=86 THEN
curval:=nxplusy(eqtb[4022+n].int,curval,0)
ELSE
curval:=
xovern(eqtb[4022+n].int,curval);
2:BEGIN
r:=newspec(eqtb[2378+n].hh.rh);
IF q=86 THEN
BEGIN
mem[r+1].int:=nxplusy(mem[eqtb[2378+n].hh.rh+1].int,
curval,0);
mem[r+2].int:=nxplusy(mem[eqtb[2378+n].hh.rh+2].int,curval,0);
mem[r+3].int:=nxplusy(mem[eqtb[2378+n].hh.rh+3].int,curval,0);
END
ELSE
BEGIN
mem[r+1].int:=xovern(mem[eqtb[2378+n].hh.rh+1].int,curval
);
mem[r+2].int:=xovern(mem[eqtb[2378+n].hh.rh+2].int,curval);
mem[r+3].int:=xovern(mem[eqtb[2378+n].hh.rh+3].int,curval);
END;
END;
END;
END;
IF aritherror THEN
BEGIN
printnl(918);
BEGIN
helpptr:=2;
helpline[1]:=919;
helpline[0]:=920;
END;
error;
GOTO 10;
END;
CASE p OF
0:IF(a>=4)THEN
geqworddefin(3620+n,curval)
ELSE
eqworddefine(
3620+n,curval);
1:IF(a>=4)THEN
geqworddefin(4004+n,curval)
ELSE
eqworddefine(4004+n,
curval);
2:IF(a>=4)THEN
geqdefine(2361+n,98,curval)
ELSE
eqdefine(2361+n,98,curval
);
END;
END;
{1117}88:BEGIN
scaneightbit;
IF(a>=4)THEN
savestack[saveptr+0].int:=1073742080+curval
ELSE
savestack[
saveptr+0].int:=1073741824+curval;
scanoptional;
Scanbox;
END;
{1118}89:BEGIN
scanint;
n:=curval;
IF n<=0 THEN
p:=0
ELSE
BEGIN
p:=getnode(2*n+1);
mem[p].hh.lh:=n;
FOR j:=1 TO n DO
BEGIN
scandimen(false,false,false);
mem[p+2*j-1].int:=curval;
scandimen(false,false,false);
mem[p+2*j].int:=curval;
END;
END;
IF(a>=4)THEN
geqdefine(2634,99,p)
ELSE
eqdefine(2634,99,p);
END;
{1122}90:IF curchr=1 THEN
BEGIN
newpatterns;
GOTO 10;
printnl(927);
helpptr:=0;
error;
END
ELSE
newhyphexcep;
{1123}74:BEGIN
scantexinfo(true);
k:=curval;
scandimen(false,false,false);
fontinfo[k].int:=curval;
END;
{1124}83:Newfont;
{1132}91:Newinteracti;
OTHERS:confusion(874)
END;
10:
END;
{1134}PROCEDURE Doassignment;
BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
WHILE curcmd>69 DO
BEGIN
Prefixedcomm;
{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
END;
END;
{1138}
PROCEDURE Issuemessage;
VAR
oldsetting:0..21;
c:0..1;
s:strnumber;
BEGIN
c:=curchr;
mem[12013].hh.rh:=scantoks(false,true);
oldsetting:=selector;
selector:=21;
tokenshow(curval);
selector:=oldsetting;
flushlist(curval);
BEGIN
IF poolptr+1>poolsize THEN
overflow(129,poolsize);
END;
s:=makestring;
IF c=0 THEN
{1139}
BEGIN
IF offset+(strstart[s+1]-strstart[s])>=
maxprintline THEN
println
ELSE
printchar(32);
print(s);
Break(termout);
END
ELSE
{1142}
BEGIN
printnl(618);
print(s);
IF errhelpseen THEN
BEGIN
helpptr:=1;
helpline[0]:=941;
END
ELSE
BEGIN
helpptr:=4;
helpline[3]:=942;
helpline[2]:=943;
helpline[1]:=944;
helpline[0]:=945;
END;
error;
IF interaction<3 THEN
errhelpseen:=true;
END;
;
BEGIN
strptr:=strptr-1;
poolptr:=strstart[strptr];
END;
END;
{1146}
PROCEDURE Shiftcase;
VAR
b:halfword;
p:halfword;
t:halfword;
c:eightbits;
BEGIN
p:=scantoks(false,false);
p:=mem[curval].hh.rh;
WHILE p<>0 DO
BEGIN{1147}
t:=mem[p].hh.lh;
IF(t<3328)AND(t>=2816)THEN
BEGIN
c:=t MOD 256;
IF c<128 THEN
IF eqtb[b+c].hh.rh<>0 THEN
mem[p].hh.lh:=256*(t DIV 256)+
eqtb[b+c].hh.rh;
END;
p:=mem[p].hh.rh;
END;
begintokenli(mem[curval].hh.rh,3);
BEGIN
mem[curval].hh.rh:=avail;
avail:=curval;
{DYNUSED:=DYNUSED-1;}
END;
END;
{1151}
PROCEDURE Showwhatever;
VAR
p:halfword;
BEGIN
CASE curchr OF
0:{1152}BEGIN
gettoken;
IF csptr=0 THEN
BEGIN
printnl(956);
BEGIN
helpptr:=1;
helpline[0]:=957;
END;
backerror;
END
ELSE
BEGIN
printnl(958);
sprintcs(csptr);
printchar(61);
printcmdchr(curcmd,curchr);
IF curcmd>=94 THEN
tokenshow(curchr)
ELSE
IF curcmd=93 THEN
tokenshow(
curmark[curchr]);
IF interaction<3 THEN
BEGIN
helpptr:=0;
errorcount:=errorcount-1;
END
ELSE
BEGIN
BEGIN
helpptr:=3;
helpline[2]:=952;
helpline[1]:=953;
helpline[0]:=954;
END;
error;
END;
END;
END;
1:{1154}BEGIN
scaneightbit;
printnl(964);
printint(curval);
printchar(61);
IF eqtb[2637+curval].hh.rh=0 THEN
print(965)
ELSE
showbox(eqtb[2637+
curval].hh.rh);
IF interaction<3 THEN
BEGIN
helpptr:=0;
errorcount:=errorcount-1;
END
ELSE
BEGIN
BEGIN
helpptr:=3;
helpline[2]:=952;
helpline[1]:=953;
helpline[0]:=954;
END;
error;
END;
END;
2:{1155}BEGIN
p:=thetoks(false);
printnl(958);
tokenshow(curval);
flushlist(curval);
IF interaction<3 THEN
BEGIN
helpptr:=0;
errorcount:=errorcount-1;
END
ELSE
BEGIN
BEGIN
helpptr:=3;
helpline[2]:=952;
helpline[1]:=953;
helpline[0]:=954;
END;
error;
END;
END;
OTHERS:BEGIN
showactiviti;
printnl(955);
IF interaction<3 THEN
BEGIN
helpptr:=0;
errorcount:=errorcount-1;
END
ELSE
BEGIN
BEGIN
helpptr:=3;
helpline[2]:=952;
helpline[1]:=953;
helpline[0]:=954;
END;
error;
END;
END
END;
END;
{1159}PROCEDURE Storefmtfile;
LABEL
41,42,31,32;
VAR
j,k,l:integer;
p,q:halfword;
x:integer;
w:fourquarters;
BEGIN{1161}
IF saveptr<>0 THEN
BEGIN
printnl(967);
BEGIN
helpptr:=1;
helpline[0]:=968;
END;
BEGIN
IF interaction=3 THEN
interaction:=2;
error;
quit;
END;
END;
{1184}
IF selector<18 THEN
openerrfile;
selector:=21;
print(978);
print(jobname);
printchar(32);
printint(Abs(eqtb[3606].int)MOD 100);
printchar(46);
printint(eqtb[3605].int);
printchar(46);
printint(eqtb[3604].int);
printchar(41);
BEGIN
IF poolptr+1>poolsize THEN
overflow(129,poolsize);
END;
IF interaction=0 THEN
selector:=18
ELSE
selector:=19;
formatident:=makestring;
packjobname(979);
WHILE NOT wopenout(fmtfile)DO promptfilena(980,979);
printnl(981);
print(wmakenamestr(fmtfile));
BEGIN
strptr:=strptr-1;
poolptr:=strstart[strptr];
END;
print(formatident);
{1164}fmtfile↑.int:=157476531;
Put(fmtfile);
fmtfile↑.int:=12000;
Put(fmtfile);
fmtfile↑.int:=4277;
Put(fmtfile);
fmtfile↑.int:=1777;
Put(fmtfile);
fmtfile↑.int:=307;
Put(fmtfile);;
{1166}fmtfile↑.int:=poolptr;
Put(fmtfile);
fmtfile↑.int:=strptr;
Put(fmtfile);
FOR k:=0 TO strptr DO fmtfile↑.int:=strstart[k];
Put(fmtfile);
k:=0;
WHILE k+4<poolptr DO
BEGIN
w.b0:=strpool[k];
w.b1:=strpool[k+1];
w.b2:=strpool[k+2];
w.b3:=strpool[k+3];
fmtfile↑.qqqq:=w;
Put(fmtfile);
k:=k+4;
END;
k:=poolptr-4;
w.b0:=strpool[k];
w.b1:=strpool[k+1];
w.b2:=strpool[k+2];
w.b3:=strpool[k+3];
fmtfile↑.qqqq:=w;
Put(fmtfile);
println;
printint(strptr);
print(969);
printint(poolptr);
{1168}sortavail;
varused:=0;
fmtfile↑.int:=rover;
Put(fmtfile);
p:=0;
q:=rover;
x:=0;
REPEAT
FOR k:=p TO q+1 DO
BEGIN
fmtfile↑:=mem[k];
Put(fmtfile);
x:=x+q+2-p;
varused:=varused+q-p;
END;
p:=q+mem[q].hh.lh;
q:=mem[q+1].hh.rh;
UNTIL q=rover;
varused:=varused+12000-p;
dynused:=memend-12000;
fmtfile↑.int:=memend;
Put(fmtfile);
fmtfile↑.int:=avail;
Put(fmtfile);
FOR k:=p TO memend DO fmtfile↑:=mem[k];
Put(fmtfile);
p:=avail;
WHILE p<>0 DO
BEGIN
dynused:=dynused-1;
p:=mem[p].hh.rh;
END;
fmtfile↑.int:=varused;
Put(fmtfile);
fmtfile↑.int:=dynused;
Put(fmtfile);
println;
printint(x+memend+1-p);
print(970);
printint(varused);
printchar(44);
printint(dynused);
{1170}{1171}k:=1;
REPEAT
j:=k;
WHILE j<3582 DO
BEGIN
IF(eqtb[j].hh.rh=eqtb[j+1].hh.rh)AND(eqtb[j].hh.b0
=eqtb[j+1].hh.b0)AND(eqtb[j].hh.b1=eqtb[j+1].hh.b1)THEN
GOTO 41;
j:=j+1;
END;
l:=3583;
GOTO 31;
41:
j:=j+1;
l:=j;
WHILE j<3582 DO
BEGIN
IF(eqtb[j].hh.rh=eqtb[j+1].hh.rh)AND(eqtb[j].hh.b0
=eqtb[j+1].hh.b0)AND(eqtb[j].hh.b1=eqtb[j+1].hh.b1)THEN
GOTO 31;
j:=j+1;
END;
31:
fmtfile↑.int:=l-k;
Put(fmtfile);
WHILE k<l DO
BEGIN
fmtfile↑:=eqtb[k];
Put(fmtfile);
k:=k+1;
END;
k:=j+1;
fmtfile↑.int:=k-l;
Put(fmtfile);
UNTIL k=3583;
{1172}
REPEAT
j:=k;
WHILE j<4277 DO
BEGIN
IF eqtb[j].int=eqtb[j+1].int THEN
GOTO 42;
j:=j+1;
END;
l:=4278;
GOTO 32;
42:
j:=j+1;
l:=j;
WHILE j<4277 DO
BEGIN
IF eqtb[j].int=eqtb[j+1].int THEN
GOTO 32;
j:=j+1;
END;
32:
fmtfile↑.int:=l-k;
Put(fmtfile);
WHILE k<l DO
BEGIN
fmtfile↑:=eqtb[k];
Put(fmtfile);
k:=k+1;
END;
k:=j+1;
fmtfile↑.int:=k-l;
Put(fmtfile);
UNTIL k>4277;
{1174}fmtfile↑.int:=hashused;
Put(fmtfile);
cscount:=2356-hashused;
FOR p:=257 TO hashused DO
IF hash[p].rh<>0 THEN
BEGIN
fmtfile↑.int:=p;
Put(fmtfile);
fmtfile↑.hh:=hash[p];
Put(fmtfile);
cscount:=cscount+1;
END;
FOR p:=hashused+1 TO 2359 DO fmtfile↑.hh:=hash[p];
Put(fmtfile);
fmtfile↑.int:=cscount;
Put(fmtfile);
println;
printint(cscount);
print(971);
{1176}fmtfile↑.int:=fmemptr;
Put(fmtfile);
FOR k:=7 TO fmemptr-1 DO fmtfile↑:=fontinfo[k];
Put(fmtfile);
fmtfile↑.int:=fontptr;
Put(fmtfile);
FOR k:=1 TO fontptr DO{1178}
BEGIN
fmtfile↑.int:=fontcode[k];
Put(fmtfile);
fmtfile↑.qqqq:=fontcheck[k];
Put(fmtfile);
fmtfile↑.int:=fontsize[k];
Put(fmtfile);
IF fontscaled[k]THEN
BEGIN
fmtfile↑.int:=1;
Put(fmtfile);
END
ELSE
BEGIN
fmtfile↑.int:=0;
Put(fmtfile);
END;
fmtfile↑.int:=fontparams[k];
Put(fmtfile);
fmtfile↑.int:=fontname[k];
Put(fmtfile);
fmtfile↑.int:=fontarea[k];
Put(fmtfile);
fmtfile↑.int:=fontbc[k];
Put(fmtfile);
fmtfile↑.int:=fontec[k];
Put(fmtfile);
fmtfile↑.int:=charbase[k];
Put(fmtfile);
fmtfile↑.int:=widthbase[k];
Put(fmtfile);
fmtfile↑.int:=heightbase[k];
Put(fmtfile);
fmtfile↑.int:=depthbase[k];
Put(fmtfile);
fmtfile↑.int:=italicbase[k];
Put(fmtfile);
fmtfile↑.int:=ligkernbase[k];
Put(fmtfile);
fmtfile↑.int:=kernbase[k];
Put(fmtfile);
fmtfile↑.int:=extenbase[k];
Put(fmtfile);
fmtfile↑.int:=parambase[k];
Put(fmtfile);
fmtfile↑.int:=fontglue[k];
Put(fmtfile);
printnl(974);
printint(fontcode[k]);
printchar(61);
printfilenam(fontname[k],fontarea[k],529);
IF fontscaled[k]THEN
BEGIN
print(544);
printscaled(fontsize[k]);
print(482);
END;
END;
FOR k:=0 TO badfontcode-1 DO
IF(fontnumber[k]<>0)AND(fontcode[fontnumber
[k]]<>k)THEN
BEGIN
fmtfile↑.int:=fontnumber[k];
Put(fmtfile);
fmtfile↑.int:=k;
Put(fmtfile);
END;
fmtfile↑.int:=0;
Put(fmtfile);
println;
printint(fmemptr-7);
print(972);
printint(fontptr-0);
print(973);
{1180}fmtfile↑.int:=hyphcount;
Put(fmtfile);
FOR k:=0 TO 307 DO
IF hyphword[k]<>0 THEN
BEGIN
fmtfile↑.int:=k;
Put(fmtfile);
fmtfile↑.int:=hyphword[k];
Put(fmtfile);
fmtfile↑.int:=hyphlist[k];
Put(fmtfile);
END;
fmtfile↑.int:=triemax;
Put(fmtfile);
FOR k:=0 TO triemax DO fmtfile↑.hh:=trie[k];
Put(fmtfile);
fmtfile↑.int:=trieopptr;
Put(fmtfile);
FOR k:=1 TO trieopptr DO
BEGIN
fmtfile↑.int:=hyfdistance[k];
Put(fmtfile);
fmtfile↑.int:=hyfnum[k];
Put(fmtfile);
fmtfile↑.int:=hyfnext[k];
Put(fmtfile);
END;
println;
printint(hyphcount);
print(975);
printnl(976);
printint(triemax);
print(564);
printint((trieopptr-0));
print(977);
{1182}fmtfile↑.int:=interaction;
Put(fmtfile);
fmtfile↑.int:=formatident;
Put(fmtfile);
fmtfile↑.int:=69069;
Put(fmtfile);
wclose(fmtfile);
END;
{1205}{1206}PROCEDURE Newwhatsit(s:smallnumber;
w:smallnumber);
VAR
p:halfword;
BEGIN
p:=getnode(w);
mem[p].hh.b0:=8;
mem[p].hh.b1:=s;
mem[curlist.tailfield].hh.rh:=p;
curlist.tailfield:=p;
END;
{1207}
PROCEDURE Newsendwhats(w:smallnumber);
VAR
p:halfword;
BEGIN
Newwhatsit(curchr,w);
scanfourbiti;
mem[curlist.tailfield+1].hh.lh:=curval;
END;
PROCEDURE Doextension;
VAR
i,j,k:integer;
p,q,r:halfword;
BEGIN
CASE curchr OF
0:{1208}BEGIN
Newsendwhats(3);
scanoptional;
scanfilename;
mem[curlist.tailfield+1].hh.rh:=curname;
mem[curlist.tailfield+2].hh.lh:=curarea;
mem[curlist.tailfield+2].hh.rh:=curext;
END;
1:{1209}BEGIN
k:=csptr;
Newsendwhats(2);
csptr:=k;
p:=scantoks(false,false);
mem[curlist.tailfield+1].hh.rh:=curval;
END;
2:{1210}BEGIN
Newsendwhats(2);
mem[curlist.tailfield+1].hh.rh:=0;
END;
3:{1212}BEGIN
Newwhatsit(3,2);
mem[curlist.tailfield+1].hh.lh:=0;
p:=scantoks(false,true);
mem[curlist.tailfield+1].hh.rh:=curval;
END;
OTHERS:confusion(994)
END;
END;
{938}
PROCEDURE Handlerightb;
LABEL
30,10;
VAR
p:halfword;
BEGIN
CASE curgroup OF
1:unsave;
0:BEGIN
printnl(728);
BEGIN
helpptr:=2;
helpline[1]:=729;
helpline[0]:=730;
END;
error;
END;
15,16,17:Extrarightbr;
{955}2:Package(0);
3:BEGIN
Endgraf;
Package(0);
END;
4:BEGIN
Endgraf;
Package(4);
END;
{970}13:BEGIN
Endgraf;
unsave;
saveptr:=saveptr-1;
IF curlist.headfield<>curlist.tailfield THEN
BEGIN
p:=vpackage(mem[
curlist.headfield].hh.rh,0,1,134217727);
popnest;
IF savestack[saveptr+0].int<255 THEN
BEGIN
BEGIN
mem[curlist.tailfield].
hh.rh:=getnode(3);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b0:=3;
mem[curlist.tailfield].hh.b1:=(savestack[saveptr+0].int+0);
mem[curlist.tailfield+1].int:=mem[p+3].int+mem[p+2].int;
mem[curlist.tailfield+2].int:=mem[p+5].hh.rh;
END
ELSE
BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=getnode(2);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b0:=5;
mem[curlist.tailfield].hh.b1:=0;
mem[curlist.tailfield+1].int:=mem[p+5].hh.rh;
END;
freenode(p,7);
END;
{365}
BEGIN
getnctoken;
IF curcmd<>10 THEN
backinput;
END;
END;
10:{896}BEGIN
unsave;
outputactive:=false;
{897}
IF eqtb[2892].hh.rh<>0 THEN
BEGIN
BEGIN
helpptr:=3;
helpline[2]:=688;
helpline[1]:=689;
helpline[0]:=690;
END;
printnl(691);
error;
flushnodelis(eqtb[2892].hh.rh);
eqtb[2892].hh.rh:=0;
END;
IF curlist.tailfield<>curlist.headfield THEN
BEGIN
mem[curlist.tailfield
].hh.rh:=mem[12001].hh.rh;
mem[12001].hh.rh:=mem[curlist.headfield].hh.rh;
END;
popnest;
buildpage;
END;
{988}12:Builddiscret;
{1006}9:BEGIN
Endgraf;
unsave;
alignpeek;
END;
{1037}14:BEGIN
Endgraf;
unsave;
saveptr:=saveptr-2;
p:=vpackage(mem[curlist.headfield].hh.rh,savestack[saveptr+1].int,
savestack[saveptr+0].int,134217727);
popnest;
BEGIN
mem[curlist.tailfield].hh.rh:=newnoad;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b0:=28;
mem[curlist.tailfield+1].hh.rh:=2;
mem[curlist.tailfield+1].hh.lh:=p;
END;
{1053}11:BEGIN
unsave;
saveptr:=saveptr-1;
mem[savestack[saveptr+0].int].hh.rh:=3;
mem[savestack[saveptr+0].int].hh.lh:=Finmlist(0);
END;
{1084}5:BEGIN
leavetranspa;
{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF curcmd=57 THEN
passblock(0)
ELSE
BEGIN
printnl(856);
BEGIN
helpptr:=3;
helpline[2]:=860;
helpline[1]:=858;
helpline[0]:=859;
END;
backerror;
END;
END;
6:BEGIN
leavetranspa;
{365}
BEGIN
getnctoken;
IF curcmd<>10 THEN
backinput;
END;
END;
{1088}7:BEGIN
leavetranspa;
WHILE true DO
BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
IF curcmd=1 THEN
passblock(1)
ELSE
IF curcmd=57 THEN
GOTO 30
ELSE
{1089}
BEGIN
printnl(864);
BEGIN
helpptr:=3;
helpline[2]:=865;
helpline[1]:=866;
helpline[0]:=859;
END;
backerror;
GOTO 10;
END;
END;
30:
passblock(0);
END;
OTHERS:confusion(731)
END;
10:
END;
PROCEDURE Maincontrol;
LABEL
60,21,70,71,72,73,74,10;
VAR
t:integer;
{900}l:quarterword;
c:eightbits;
f:internalfont;
r:halfword;
p:halfword;
k:0..fontmemsize;
q:halfword;
i:fourquarters;
j:fourquarters;
s:integer;
ligaturepres:boolean;
BEGIN
60:
getnctoken;
BEGIN
IF interrupt<>0 THEN
pauseforinst;
END;
{IF PANICKING THEN CHECKMEM(FALSE);
}21:
CASE Abs(curlist.modefield)+curcmd OF
104,105:GOTO 70;
109:BEGIN
scancharnum;
curchr:=curval;
GOTO 70;
END;
103:IF curlist.auxfield=1000 THEN
GOTO 74
ELSE
Appspace;
156,248:GOTO 74;
{914}1,93,185,11,14,195:;
40,132,224:BEGIN{362}
REPEAT
getnctoken;
UNTIL curcmd<>10;
GOTO 21;
END;
20:startinput;
15:GOTO 10;
{919}112,204,{925}36,129,221,{943}24,115,207,{961}226,{968}39,223,{981}
209,43,{995}228,{1003}34,125,218,{1015}47,139,7,99,191:Reportillega;
{917}8,100,9,101,18,110,49,141,16,108,48,140,51,143,65,157,52,144,54,146
,53,145,31,123,50,142,29,121,45,137,194,198,199,212:BEGIN
Insertdollar;
GOTO 21;
END;
{924}37,128,220:BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=scanrulespec;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
IF Abs(curlist.modefield)=1 THEN
curlist.auxfield:=-65536000;
END;
{926}28,119,211,213:Appendglue;
30,122,214,215:Appendkern;
{932}2,94:newsavelevel(1);
61,153,245:newsavelevel(15);
62,154,246:IF curgroup=15 THEN unsave ELSE Offsave;
{937}3,95,187:Handlerightb;
{942}23,116,208:BEGIN
t:=curchr;
scandimen(false,false,false);
IF t=0 THEN
savestack[saveptr+0].int:=curval
ELSE
savestack[saveptr+0].int:=-curval;
Scanbox;
END;
32,124,216:BEGIN
savestack[saveptr+0].int:=1073742237+curchr;
Scanbox;
END;
22,114,206:BEGIN
savestack[saveptr+0].int:=0;
Beginbox;
END;
{960}42:Newgraf(curchr>0);
12,13,17,4,66,67,44,46,27,64,68:BEGIN
Newgraf(true);
GOTO 21;
END;
{963}134:Indentinhmod;
{965}106:BEGIN
Endgraf;
IF curlist.modefield=1 THEN buildpage;
END;
107,120:BEGIN
backinput;
curtok:=partoken;
csptr:=parloc;
curcmd:=eqtb[csptr].hh.b0;
curchr:=eqtb[csptr].hh.rh;
GOTO 21;
END;
{967}38,130,222,131:Begininserto;
19,111,203:Makemark;
{972}70,162,254:Changeaux;
{974}41,133,225:Appendpenalt;
{976}26,118,210:Deleteskip;
{979}25,117:Unpackage;
{982}135:Appenditalic;
227:BEGIN
mem[curlist.tailfield].hh.rh:=newkern(0);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
{986}138,230:Appenddiscre;
{992}158,250:BEGIN
mem[12013].hh.rh:=thetoks(curchr>0);
begintokenli(curval,3);
END;
159,251:BEGIN
mem[12013].hh.rh:=numtoks;
begintokenli(curval,3);
END;
160,252,161,253:Insthe;
{994}136:Makeaccent;
{999}6,98,190,5,97,189:BEGIN
Alignerror;
GOTO 21;
END;
35,127,219:Noalignerror;
63,155,247:Omiterror;
{1004}33,126:initalign;
217:IF Privileged THEN
IF curgroup=16 THEN
initalign
ELSE
Offsave;
10,102:Doendv;
{1007}96:Initmath;
{1011}231:IF Privileged THEN Starteqno;
{1021}186:BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=newnoad;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
backinput;
Scanmath(curlist.tailfield+1);
END;
{1024}196,197:Setmathchar(eqtb[3071+curchr].hh.rh);
201:BEGIN
scancharnum;
Setmathchar(curval+28672);
END;
202:BEGIN
scanfifteenb;
Setmathchar(curval);
END;
200:BEGIN
scantwentyse;
Setmathchar(curval DIV 4096);
END;
{1028}233:BEGIN
BEGIN
mem[curlist.tailfield].hh.rh:=newnoad;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield].hh.b0:=curchr;
Scanmath(curlist.tailfield+1);
END;
234:Mathlimitswi;
{1032}249:Mathradical;
{1034}229:Mathac;
{1036}238:BEGIN
scanspec;
newsavelevel(14);
pushnest;
curlist.modefield:=-1;
curlist.auxfield:=-65536000;
END;
{1040}236:BEGIN
mem[curlist.tailfield].hh.rh:=newstyle(curchr);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
237:Mathnonscrip;
{1042}193,192:Subsup;
{1047}235:Mathfraction;
{1056}232:Mathleftrigh;
{1059}188:IF curgroup=16 THEN
Finmath
ELSE
Offsave;
{1075}56,148,240:Conditional;
{1085}57,149,241:Caseconditio;
58,150,242:Spuriouselse;
{1092}71,163,255,72,164,256,73,165,257,74,166,258,75,167,259,76,168,260,
77,169,261,78,170,262,79,171,263,80,172,264,81,173,265,82,174,266,83,175
,267,84,176,268,85,177,269,86,178,270,87,179,271,88,180,272,89,181,273,
90,182,274,91,183,275,92,184,276:Prefixedcomm;
{1135}59,151,243:Issuemessage;
{1143}55,147,239:Shiftcase;
{1148}21,113,205:Showwhatever;
{1204}60,152,244:Doextension;
END;
GOTO 60;
70:{901}
f:=eqtb[2893].hh.rh;
IF f=0 THEN
BEGIN
Missingfont;
GOTO 60;
END;
c:=curchr;
71:
IF(c<fontbc[f])OR(c>fontec[f])THEN
BEGIN
charwarning(f,c);
GOTO 60;
END;
72:
q:=curlist.tailfield;
ligaturepres:=false;
l:=(c+0);
73:{903}
IF c<128 THEN
BEGIN
s:=eqtb[3455+c].hh.rh;
IF s=1000 THEN
curlist.auxfield:=1000
ELSE
IF s<1000 THEN
BEGIN
IF s>0 THEN curlist.auxfield:=s;
END
ELSE
IF curlist.auxfield<1000 THEN curlist.auxfield:=1000
ELSE curlist.auxfield:=s;
END
ELSE
curlist.auxfield:=1000;
{904}i:=fontinfo[charbase[f]+l].qqqq;
IF(i.b0>0)THEN
BEGIN
p:=avail;
IF p=0 THEN p:=getavail
ELSE
BEGIN
avail:=mem[p].hh.rh;
mem[p].hh.rh:=0;
{DYNUSED:=DYNUSED+1;}
END;
mem[p].hh.b0:=f;
mem[p].hh.b1:=(c+0);
mem[curlist.tailfield].hh.rh:=p;
curlist.tailfield:=p;
END
ELSE
charwarning(f,(l-0));
{905}getnext;
IF(curcmd=11)OR(curcmd=12)THEN r:=(curchr+0)
ELSE
BEGIN
nctoken;
IF curcmd=16 THEN
BEGIN
scancharnum;
r:=(curval+0);
END
ELSE
r:=(256);
END;
IF(((i.b2-0)MOD 4)=1)AND(r<>(256))THEN
{906}
BEGIN
k:=ligkernbase[f]+i.b3;
REPEAT
j:=fontinfo[k].qqqq;
IF j.b1=r THEN
IF j.b2<128 THEN
{909}
BEGIN
ligaturepres:=true;
l:=j.b3;
c:=(r-0);
GOTO 73;
END
ELSE
{907}
BEGIN{908}
IF ligaturepres THEN
BEGIN
p:=newligature(f,c,mem[q].hh.rh);
mem[q].hh.rh:=p;
curlist.tailfield:=p;
END;
IF c=45 THEN
BEGIN
mem[curlist.tailfield].hh.rh:=newdisc;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
BEGIN
mem[curlist.tailfield].hh.rh:=newkern(fontinfo[kernbase[f]+j.b3].int);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
c:=(r-0);
GOTO 72;
END;
k:=k+1;
UNTIL j.b0>=128;
END;
{908}
IF ligaturepres THEN
BEGIN
p:=newligature(f,c,mem[q].hh.rh);
mem[q].hh.rh:=p;
curlist.tailfield:=p;
END;
IF c=45 THEN
BEGIN
mem[curlist.tailfield].hh.rh:=newdisc;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
IF r=(256)THEN
GOTO 21;
c:=(r-0);
GOTO 71;;
74:{910}
IF eqtb[2372].hh.rh=0 THEN
BEGIN{911}
BEGIN
p:=fontglue[eqtb[2893
].hh.rh];
IF p=0 THEN
BEGIN
f:=eqtb[2893].hh.rh;
p:=newspec(0);
k:=parambase[f]+2;
mem[p+1].int:=fontinfo[k].int;
mem[p+2].int:=fontinfo[k+1].int;
mem[p+3].int:=fontinfo[k+2].int;
fontglue[f]:=p;
END;
END;
q:=newglue(p);
END
ELSE
q:=newparamglue(11);
mem[curlist.tailfield].hh.rh:=q;
curlist.tailfield:=q;
GOTO 60;
10:
END;
{1160}{439}FUNCTION Openfmtfile:boolean;
LABEL
40,10;
VAR
j:0..bufsize;
BEGIN
IF buffer[curinput.locfield]<>92 THEN
BEGIN
j:=curinput.locfield+1
;
buffer[curinput.limitfield]:=32;
WHILE buffer[j]<>32 DO j:=j+1;
packbuffered(0,curinput.locfield,j-1);
IF wopenin(fmtfile)THEN
BEGIN
curinput.locfield:=j;
GOTO 40;
END;
packbuffered(13,curinput.locfield,j-1);
IF wopenin(fmtfile)THEN
BEGIN
curinput.locfield:=j;
GOTO 40;
END;
END;
packbuffered(18,1,0);
IF NOT wopenin(fmtfile)THEN
BEGIN
Writeln(termout,
'I can''t find the BASIC format file!');
Openfmtfile:=false;
GOTO 10;
END;
40:
Openfmtfile:=true;
10:
END;
FUNCTION Loadfmtfile:boolean;
LABEL
6666,10;
VAR
j,k:integer;
p,q:halfword;
x,y:integer;
w:fourquarters;
BEGIN{1165}
Get(fmtfile);
x:=fmtfile↑.int;
IF x<>157476531 THEN
GOTO 6666;
Get(fmtfile);
x:=fmtfile↑.int;
IF x<>12000 THEN
GOTO 6666;
Get(fmtfile);
x:=fmtfile↑.int;
IF x<>4277 THEN
GOTO 6666;
Get(fmtfile);
x:=fmtfile↑.int;
IF x<>1777 THEN
GOTO 6666;
Get(fmtfile);
x:=fmtfile↑.int;
IF x<>307 THEN
GOTO 6666;
;
{1167}Get(fmtfile);
x:=fmtfile↑.int;
IF x<0 THEN
GOTO 6666;
IF x>poolsize THEN
BEGIN
Write(termout,'---! Must increase the ','string pool size');
GOTO 6666;
END
ELSE poolptr:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF x<0 THEN GOTO 6666;
IF x>maxstrings THEN
BEGIN
Write(termout,'---! Must increase the ','max strings');
GOTO 6666;
END
ELSE
strptr:=x;
FOR k:=0 TO strptr DO Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>poolptr)THEN GOTO 6666
ELSE strstart[k]:=x;
k:=0;
WHILE k+4<poolptr DO
BEGIN
Get(fmtfile);
w:=fmtfile↑.qqqq;
strpool[k]:=w.b0;
strpool[k+1]:=w.b1;
strpool[k+2]:=w.b2;
strpool[k+3]:=w.b3;
k:=k+4;
END;
k:=poolptr-4;
Get(fmtfile);
w:=fmtfile↑.qqqq;
strpool[k]:=w.b0;
strpool[k+1]:=w.b1;
strpool[k+2]:=w.b2;
strpool[k+3]:=w.b3;
{1169}Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>12000)THEN GOTO 6666
ELSE rover:=x;
p:=0;
q:=rover;
x:=0;
REPEAT
FOR k:=p TO q+1 DO Get(fmtfile);
mem[k]:=fmtfile↑;
p:=q+mem[q].hh.lh;
IF(p>12000)OR((q<=mem[q+1].hh.rh)AND(q<>rover))THEN GOTO 6666;
q:=mem[q+1].hh.rh;
UNTIL q=rover;
Get(fmtfile);
x:=fmtfile↑.int;
IF x<12000 THEN GOTO 6666;
IF x>memmax THEN
BEGIN
Write(termout,'---! Must increase the ','mem max');
GOTO 6666;
END
ELSE
memend:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<12000)OR(x>memend)THEN GOTO 6666
ELSE avail:=x;
FOR k:=p TO memend DO Get(fmtfile);
mem[k]:=fmtfile↑;
Get(fmtfile);
varused:=fmtfile↑.int;
Get(fmtfile);
dynused:=fmtfile↑.int;
maxvarused:=varused;
{1175}{1173}k:=1;
REPEAT
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<1)OR(k+x>4277)THEN GOTO 6666;
FOR j:=k TO k+x-1 DO Get(fmtfile);
eqtb[j]:=fmtfile↑;
k:=k+x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(k+x>4278)THEN GOTO 6666;
FOR j:=k TO k+x-1 DO eqtb[j]:=eqtb[k-1];
k:=k+x;
UNTIL k>4277;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<257)OR(x>2357)THEN GOTO 6666
ELSE hashused:=x;
p:=256;
REPEAT
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<p+1)OR(x>hashused)THEN GOTO 6666
ELSE p:=x;
Get(fmtfile);
hash[p]:=fmtfile↑.hh;
UNTIL p=hashused;
FOR p:=hashused+1 TO 2359 DO Get(fmtfile);
hash[p]:=fmtfile↑.hh;
Get(fmtfile);
cscount:=fmtfile↑.int;
{1177}Get(fmtfile);
x:=fmtfile↑.int;
IF x<7 THEN GOTO 6666;
IF x>fontmemsize THEN
BEGIN
Write(termout,'---! Must increase the ','font mem size');
GOTO 6666;
END
ELSE
fmemptr:=x;
FOR k:=7 TO fmemptr-1 DO Get(fmtfile);
fontinfo[k]:=fmtfile↑;
Get(fmtfile);
x:=fmtfile↑.int;
IF x<0 THEN GOTO 6666;
IF x>fontmax THEN
BEGIN
Write(termout,'---! Must increase the ','font max');
GOTO 6666;
END
ELSE
fontptr:=x;
FOR k:=1 TO fontptr DO{1179}
BEGIN
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>badfontcode)THEN GOTO 6666
ELSE fontcode[k]:=x;
fontnumber[fontcode[k]]:=k;
Get(fmtfile);
fontcheck[k]:=fmtfile↑.qqqq;
Get(fmtfile);
fontsize[k]:=fmtfile↑.int;
Get(fmtfile);
x:=fmtfile↑.int;
IF x=0 THEN fontscaled[k]:=false
ELSE IF x=1 THEN fontscaled[k]:=true
ELSE GOTO 6666;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>65535)THEN GOTO 6666
ELSE fontparams[k]:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>strptr)THEN GOTO 6666
ELSE fontname[k]:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>strptr)THEN GOTO 6666
ELSE fontarea[k]:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>255)THEN GOTO 6666
ELSE fontbc[k]:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>255)THEN GOTO 6666
ELSE fontec[k]:=x;
Get(fmtfile);
charbase[k]:=fmtfile↑.int;
Get(fmtfile);
widthbase[k]:=fmtfile↑.int;
Get(fmtfile);
heightbase[k]:=fmtfile↑.int;
Get(fmtfile);
depthbase[k]:=fmtfile↑.int;
Get(fmtfile);
italicbase[k]:=fmtfile↑.int;
Get(fmtfile);
ligkernbase[k]:=fmtfile↑.int;
Get(fmtfile);
kernbase[k]:=fmtfile↑.int;
Get(fmtfile);
extenbase[k]:=fmtfile↑.int;
Get(fmtfile);
parambase[k]:=fmtfile↑.int;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>12000)THEN GOTO 6666
ELSE fontglue[k]:=x;
END;
REPEAT
Get(fmtfile);
y:=fmtfile↑.int;
IF Eof(fmtfile)THEN
GOTO 6666;
IF y<>0 THEN
BEGIN
IF(y<0)OR(y>=fontptr)THEN GOTO 6666;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>badfontcode)THEN GOTO 6666
ELSE k:=x;
fontnumber[k]:=y;
END;
UNTIL y=0;
{1181}Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>307)THEN GOTO 6666
ELSE hyphcount:=x;
FOR k:=1 TO hyphcount DO
BEGIN
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>307)THEN GOTO 6666
ELSE j:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>strptr)THEN GOTO 6666
ELSE hyphword[k]:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>65535)THEN GOTO 6666
ELSE hyphlist[k]:=x;
END;
Get(fmtfile);
x:=fmtfile↑.int;
IF x<0 THEN GOTO 6666;
IF x>triesize THEN
BEGIN
Write(termout,'---! Must increase the ','trie size');
GOTO 6666;
END
ELSE
triemax:=x;
FOR k:=0 TO triemax DO Get(fmtfile);
trie[k]:=fmtfile↑.hh;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>255)THEN GOTO 6666
ELSE trieopptr:=x;
FOR k:=1 TO trieopptr DO
BEGIN
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>63)THEN GOTO 6666
ELSE hyfdistance[k]:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>63)THEN GOTO 6666
ELSE hyfnum[k]:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>255)THEN GOTO 6666
ELSE hyfnext[k]:=x;
END;
{1183}Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>3)THEN GOTO 6666
ELSE interaction:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<0)OR(x>strptr)THEN GOTO 6666
ELSE formatident:=x;
Get(fmtfile);
x:=fmtfile↑.int;
IF(x<>69069)OR Eof(fmtfile)THEN GOTO 6666;
Loadfmtfile:=true;
GOTO 10;
6666:
Loadfmtfile:=false;
10:
END;
{1185}{1189}PROCEDURE Closefilesan;
VAR
k:integer;
BEGIN{DEBUGHELP;
}{549}
IF totalpages=0 THEN
printnl(574)
ELSE
BEGIN
BEGIN
dvibuf[dviptr]:=
240;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
dvifour(lastbop);
lastbop:=dvioffset+dviptr-5;
dvifour(25400000);
dvifour(473628672);
preparemag;
dvifour(eqtb[3600].int);
dvifour(maxv);
dvifour(maxh);
BEGIN
dvibuf[dviptr]:=maxpush DIV 256;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
BEGIN
dvibuf[dviptr]:=maxpush MOD 256;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
BEGIN
dvibuf[dviptr]:=totalpages DIV 256;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
BEGIN
dvibuf[dviptr]:=totalpages MOD 256;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
{550}
WHILE fontptr>0 DO
BEGIN
IF fontused[fontptr]THEN
BEGIN
dvifour(
fontptr-1);
BEGIN
dvibuf[dviptr]:=(fontcheck[fontptr].b0-0);
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
BEGIN
dvibuf[dviptr]:=(fontcheck[fontptr].b1-0);
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
BEGIN
dvibuf[dviptr]:=(fontcheck[fontptr].b2-0);
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
BEGIN
dvibuf[dviptr]:=(fontcheck[fontptr].b3-0);
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
dvifour(fontsize[fontptr]);
BEGIN
dvibuf[dviptr]:=(strstart[fontarea[fontptr]+1]-strstart[fontarea[
fontptr]]);
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
BEGIN
dvibuf[dviptr]:=(strstart[fontname[fontptr]+1]-strstart[fontname[
fontptr]]);
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
{551}
FOR k:=strstart[fontarea[fontptr]]TO strstart[fontarea[fontptr]+1]
-1 DO
BEGIN
dvibuf[dviptr]:=strpool[k];
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
FOR k:=strstart[fontname[fontptr]]TO strstart[fontname[fontptr]+1]-1 DO
BEGIN
dvibuf[dviptr]:=strpool[k];
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
END;
fontptr:=fontptr-1;
END;
dvifour(-1);
dvifour(lastbop);
BEGIN
dvibuf[dviptr]:=2;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
k:=4+((dvibufsize-dviptr)MOD 4);
WHILE k>0 DO
BEGIN
BEGIN
dvibuf[dviptr]:=223;
dviptr:=dviptr+1;
IF dviptr=dvilimit THEN
dviswap;
END;
k:=k-1;
END;
{510}
IF dvilimit=halfbuf THEN
writedvi(halfbuf,dvibufsize-1);
IF dviptr>0 THEN
writedvi(0,dviptr-1);
printnl(575);
print(outputfilena);
printchar(46);
bclose(dvifile);
END;
{1224}
FOR k:=0 TO 15 DO
IF sendopen[k]THEN
aclose(sendfile[k]);
{IF EQTB[3614].INT<>0 THEN[1190]PRINTNL(982);
PRINTINT(MAXVARUSED);
PRINTCHAR(44);
PRINTINT(MEMEND-12000);
PRINTLN;
PRINTINT(CSCOUNT);
PRINT(983);
PRINTLN;
PRINTINT(TOTALPAGES);
PRINT(984)PRINTINT(DIVPTR);
PRINT(985);}
IF jobname<>0 THEN
BEGIN
Writeln(errfile);
aclose(errfile);
END;
END;
{1191}
PROCEDURE Finalcleanup;
LABEL
30,10;
VAR
c:smallnumber;
k:smallnumber;
BEGIN
c:=curchr;
IF jobname=0 THEN
openerrfile;
{1192}k:=0;
WHILE true DO
BEGIN
buildpage;
IF 12002=pagetail THEN
GOTO 30;
BEGIN
mem[curlist.tailfield].hh.rh:=newnullbox;
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
mem[curlist.tailfield+1].int:=eqtb[4008].int;
BEGIN
mem[curlist.tailfield].hh.rh:=newpenalty(-10000);
curlist.tailfield:=mem[curlist.tailfield].hh.rh;
END;
k:=k+1;
IF k>25 THEN
BEGIN
printnl(988);
GOTO 30;
END;
END;
30:;
IF curlevel>0 THEN
BEGIN
printnl(986);
printint(curlevel);
printchar(41);
END;
IF c=1 THEN
BEGIN
Storefmtfile;
GOTO 10;
printnl(987);
END;
10:
END;
{1194}
PROCEDURE Initprim;
BEGIN
nonewcontrol:=false;
{216}primitive(226,73,0);
primitive(227,73,1);
primitive(228,73,2);
primitive(229,73,3);
primitive(230,73,4);
primitive(231,73,5);
primitive(232,73,6);
primitive(233,73,7);
primitive(234,73,8);
primitive(235,73,9);
primitive(236,73,10);
primitive(237,73,11);
primitive(238,73,12);
primitive(239,73,13);
primitive(240,73,14);
primitive(241,73,15);
primitive(242,73,16);
{219}primitive(244,70,2635);
primitive(245,70,2636);
{224}primitive(246,71,0);
primitive(247,71,1);
primitive(248,71,2);
primitive(249,71,3);
primitive(250,71,4);
primitive(251,71,5);
primitive(252,71,6);
primitive(253,71,7);
primitive(254,71,8);
primitive(255,71,9);
primitive(256,71,10);
primitive(257,71,11);
primitive(258,71,10);
primitive(259,71,13);
primitive(260,71,14);
primitive(261,71,15);
primitive(262,71,16);
primitive(263,71,17);
primitive(264,71,18);
primitive(265,71,19);
primitive(266,71,20);
primitive(267,71,21);
primitive(268,71,22);
primitive(269,71,23);
primitive(270,71,24);
primitive(271,71,25);
primitive(272,71,26);
primitive(273,71,27);
primitive(274,71,28);
primitive(275,71,29);
primitive(276,71,30);
primitive(277,71,31);
primitive(278,71,32);
primitive(279,71,33);
primitive(280,71,34);
primitive(281,71,35);
primitive(282,71,36);
{229}primitive(284,72,0);
primitive(285,72,1);
primitive(286,72,2);
primitive(287,72,3);
primitive(288,72,4);
primitive(289,72,5);
primitive(290,72,6);
primitive(291,72,7);
primitive(292,72,8);
primitive(293,72,9);
primitive(294,72,10);
primitive(295,72,11);
primitive(296,72,12);
primitive(297,72,13);
primitive(298,72,14);
primitive(299,72,15);
primitive(300,72,16);
{246}primitive(306,0,0);
primitive(307,81,0);
primitive(308,16,0);
primitive(309,17,0);
primitive(310,18,0);
primitive(311,19,0);
primitive(312,40,0);
primitive(313,83,0);
primitive(58,78,0);
primitive(314,79,0);
primitive(315,66,0);
primitive(316,88,0);
primitive(317,24,0);
primitive(318,25,0);
primitive(319,68,0);
primitive(320,32,0);
primitive(321,33,0);
primitive(322,34,0);
primitive(323,35,0);
primitive(324,36,0);
primitive(189,37,0);
primitive(208,38,0);
primitive(325,39,0);
primitive(326,89,0);
primitive(47,42,0);
primitive(327,43,0);
primitive(328,44,0);
primitive(329,15,0);
primitive(330,49,0);
primitive(331,52,0);
primitive(332,53,0);
primitive(333,62,0);
primitive(334,60,0);
primitive(335,61,0);
primitive(32,63,0);
primitive(336,64,0);
{310}primitive(383,13,0);
parloc:=curval;
partoken:=4096+parloc;
{343}primitive(412,93,0);
primitive(413,93,1);
primitive(414,93,2);
primitive(415,93,3);
primitive(416,93,4);
{369}primitive(443,67,0);
primitive(444,67,1);
primitive(445,67,2);
primitive(446,75,17);
primitive(447,65,0);
primitive(448,65,1);
{374}primitive(451,69,93);
primitive(452,69,1);
{672}primitive(355,4,128);
primitive(357,5,129);
{915}primitive(697,14,0);
primitive(698,14,1);
{927}primitive(708,26,4);
primitive(709,26,0);
primitive(710,26,1);
primitive(711,26,2);
primitive(712,26,3);
primitive(713,27,4);
primitive(714,27,0);
primitive(715,27,1);
primitive(716,27,2);
primitive(717,27,3);
primitive(193,28,5);
primitive(196,29,0);
primitive(197,30,98);
{940}primitive(738,22,1);
primitive(739,22,0);
primitive(740,23,1);
primitive(741,23,0);
primitive(742,21,0);
primitive(743,21,1);
primitive(744,21,2);
primitive(745,21,3);
primitive(746,21,4);
primitive(747,21,5);
primitive(748,21,97);
primitive(749,31,100);
primitive(750,31,101);
primitive(751,31,102);
{958}primitive(765,41,1);
primitive(766,41,0);
{984}primitive(45,45,1);
primitive(204,45,0);
{1012}primitive(804,46,0);
primitive(805,46,1);
{1026}primitive(598,48,15);
primitive(599,48,16);
primitive(600,48,17);
primitive(601,48,10⊂$v~∀@↓aeS[%iSmJ l`dXPpXbr$v~∀@↓aeS[%iSmJ l`fXPpXd`$v~∀@↓aeS[%iSmJ l`hXPpXdb$v~∀@↓aeS[%iSmJ l`lXPpXdj$v~∀@↓aeS[%iSmJ l`jXPpXdl$v~∀@{1038}primitive(593,51,0);
primitive(594,51,2);
primitive(595,51,4);
primitive(596,51,6);
{1045}primitive(822,50,0);
primitive(823,50,1);
primitive(824,50,2);
primitive(609,50,3);
primitive(825,50,4);
primitive(826,50,5);
{1054}primitive(607,47,29);
primitive(608,47,30);
{1073}primitive(839,55,0);
primitive(840,55,1);
primitive(841,55,2);
primitive(842,55,3);
primitive(843,55,4);
primitive(844,55,5);
primitive(845,55,6);
primitive(846,55,7);
primitive(847,55,8);
primitive(848,55,9);
{1090}primitive(867,80,1);
primitive(868,80,2);
primitive(869,80,4);
primitive(870,82,0);
primitive(871,82,1);
primitive(872,82,2);
primitive(873,82,3);
{1105}primitive(889,76,2943);
primitive(890,76,3071);
primitive(891,76,3199);
primitive(892,76,3327);
primitive(893,76,3455);
primitive(894,76,3876);
primitive(614,77,2894);
primitive(615,77,2910);
primitive(616,77,2926);
{1110}primitive(902,84,0);
primitive(903,84,1);
primitive(904,84,2);
primitive(905,85,0);
primitive(906,85,1);
primitive(907,85,2);
primitive(908,86,0);
primitive(909,86,1);
primitive(910,86,2);
primitive(911,87,0);
primitive(912,87,1);
primitive(913,87,2);
{1120}primitive(925,90,0);
primitive(926,90,1);
{1130}primitive(935,91,0);
primitive(936,91,1);
primitive(937,91,2);
primitive(938,91,3);
{1136}primitive(939,58,0);
primitive(940,58,1);
{1144}primitive(946,54,3199);
primitive(947,54,3327);
{1149}primitive(948,20,0);
primitive(949,20,1);
primitive(950,20,2);
primitive(951,20,3);
{1202}primitive(989,59,0);
primitive(990,59,1);
primitive(991,59,2);
primitive(992,59,3);;
nonewcontrol:=true;
END;
{1196}{PROCEDURE DEBUGHELP;
LABEL 889,888,10;
VAR K,L,M,N:INTEGER;
BEGIN GOTO 889;
888:['*************breakpoint*************';
'***********for**debugging***********'];
889:WHILE TRUE DO BEGIN WRITE(TERMOUT,'#');
BREAK(TERMOUT);
READ(TERMIN,M);
IF M<0 THEN GOTO 10;
IF M=0 THEN GOTO 888;
READ(TERMIN,N);
CASE M OF[1197]1:PRINTMEMORYW(MEM[N]);
2:PRINTINT(MEM[N].HH.LH);
3:PRINTINT(MEM[N].HH.RH);
4:PRINTMEMORYW(EQTB[N]);
5:PRINTMEMORYW(FONTINFO[N]);
6:PRINTMEMORYW(SAVESTACK[N]);
7:SHOWBOX(N);
8:BEGIN BREADTHMAX:=1000;
DEPTHTHRESHO:=POOLSIZE-POOLPTR-10;
SHOWNODELIST(N);
END;
9:TOKENSHOW(N);
10:CHECKMEM(N>0);
11:SEARCHMEM(N);
12:BEGIN READ(TERMIN,L);
PRINTCMDCHR(N,L);
END;
13:FOR K:=1 TO N DO PRINT(XCHR[BUFFER[K]]);
14:BEGIN FONTINSHORTD:=0;
SHORTDISPLAY(N);
END;
OTHERS:WRITE(TERMOUT,'?')END;
END;
10:END;
}
{1188}BEGIN
1:
Rewrite(termout,'TTY:','/O');
IF readyalready=314159 THEN
GOTO 2;
initialize;
{13}bad:=0;
IF(halferrorlin<30)OR(halferrorlin>errorline-15)THEN
bad:=1;
IF maxprintline<60 THEN
bad:=2;
IF dvibufsize MOD 8<>0 THEN
bad:=3;
IF(12000<100)OR(12100>memmax)THEN
bad:=4;
IF 1777>2100 THEN
bad:=5;
{105}
IF(0>0)OR(255<127)THEN
bad:=11;
IF(0>0)OR(65535<32767)THEN
bad:=12;
IF(0<0)OR(255>65535)THEN
bad:=13;
IF(0<0)OR(memmax>=65535)THEN
bad:=14;
IF(0<0)OR(fontmax>255)THEN
bad:=15;
IF(savesize>65535)OR(maxstrings>65535)THEN
bad:=16;
IF(bufsize>65535)THEN
bad:=17;
{269}
IF 6456>65535 THEN
bad:=21;
{437}
IF 22>filenamesize THEN
bad:=31;
{1119}
IF 2*65535<12000 THEN
bad:=41;
IF bad>0 THEN
BEGIN
Write(termout,
'Ouch---my internal constants have been clobbered!');
Write(termout,'---case ',bad:0);
GOTO 9999;
END;
{1193}
IF NOT initstrings THEN
GOTO 9999;
Initprim;
{657}magicoffset:=strstart[625]-9*15;
GOTO 2;
{657}magicoffset:=strstart[625]-9*15;
2:
fixdateandti;
{54}selector:=17;
tally:=0;
offset:=0;
{58}Write(termout,'This is TeX, Version 0');
IF formatident=0 THEN
Writeln(termout,' (no format preloaded)')
ELSE
BEGIN
print(formatident);
println;
END;
{449}outputfilena:=0;;
{1195}
BEGIN{307}
BEGIN
inputptr:=0;
inopen:=0;
paramptr:=0;
scannerstatu:=0;
First:=0;
curinput.statefield:=33;
curinput.startfield:=0;
curinput.indexfield:=0;
line:=0;
curinput.namefield:=0;
alignstate:=1000000;
IF NOT initterminal THEN
GOTO 9999;
END;
IF formatident=0 THEN
BEGIN
IF NOT Openfmtfile THEN
GOTO 9999;
IF NOT Loadfmtfile THEN
GOTO 9999;
WHILE(curinput.locfield<curinput.limitfield)AND(buffer[curinput.locfield
]=32)DO curinput.locfield:=curinput.locfield+1;
END;
buffer[curinput.limitfield]:=13;
{71}
IF interaction=0 THEN
selector:=16
ELSE
selector:=17;
IF(curinput.locfield<curinput.limitfield)AND(eqtb[2943+buffer[curinput.
locfield]].hh.rh<>0)THEN
startinput;
END;
Maincontrol;
Finalcleanup;
9998:
Closefilesan;
9999:
END.